noseglid · Mar 17, 2021 · Mar 17, 2021 · Mar 18, 2021 · Mar 18, 2021 · Mar 18, 2021
diff --git a/.babelrc.json b/.babelrc.json
@@ -0,0 +1,12 @@
+{
+  "plugins": [],
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "corejs": "3.15",
+        "useBuiltIns": "entry"
+      }
+    ]
+  ]
+}
diff --git a/.editorconfig b/.editorconfig
@@ -0,0 +1,12 @@
+# EditorConfig is awesome: http://EditorConfig.org
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
diff --git a/.eslintignore b/.eslintignore
@@ -0,0 +1,3 @@
+/lib
+/node_modules
+/spec
diff --git a/.eslintrc b/.eslintrc
diff --git a/.eslintrc.json b/.eslintrc.json
@@ -0,0 +1,10 @@
+{
+  "parser": "@babel/eslint-parser",
+  "parserOptions": {
+    "sourceType": "module"
+  },
+  "rules": {
+    "new-cap": [2, { "capIsNewExceptions": ["XRegExp"] }],
+    "no-loop-func": 0
+  }
+}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -0,0 +1,29 @@
+name: Build & test
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: ['lts/*']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setting up NodeJS ${{ matrix.node-version }}
+      uses: actions/setup-node@v2
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm run lint --if-present
+    - run: npm run build --if-present
+    - run: npm run test --if-present
+      env:
+        CI: true
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
@@ -0,0 +1,22 @@
+name: 'Stale issues and PR'
+on:
+  schedule:
+    - cron: '30 1 * * *'
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v4
+        with:
+          stale-issue-label: stale
+          stale-pr-label: stale
+          stale-issue-message: 'This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 14 days.'
+          stale-pr-message: 'This PR is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 14 days.'
+          close-issue-message: 'This issue was closed because it has been stalled for 14 days with no activity.'
+          close-pr-message: 'This PR was closed because it has been stalled for 14 days with no activity.'
+          days-before-issue-stale: 90
+          days-before-pr-stale: 90
+          days-before-issue-close: 30
+          days-before-pr-close: 30
+          exempt-issue-labels: enhancement, bug
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,16 @@
-.DS_Store
-npm-debug.log
-/node_modules
+# Package Managers
+bower_components/
+node_modules/
+npm-debug.log*
+shrinkwrap.yaml
+vendor/
+yarn-error.log
+yarn.lock
+
+# Development Files
+.eslintcache
+*.d.ts
+*.map
+
+# Project-specific
+todo.md
diff --git a/.husky/pre-commit b/.husky/pre-commit
@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npx lint-staged
diff --git a/.prettierignore b/.prettierignore
@@ -0,0 +1,2 @@
+lib/
+node_modules/
diff --git a/.prettierrc.json b/.prettierrc.json
@@ -0,0 +1,16 @@
+{
+  "arrowParens": "always",
+  "bracketSpacing": true,
+  "embeddedLanguageFormatting": "auto",
+  "htmlWhitespaceSensitivity": "css",
+  "insertPragma": false,
+  "printWidth": 160,
+  "proseWrap": "preserve",
+  "quoteProps": "consistent",
+  "requirePragma": false,
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "none",
+  "useTabs": false
+}
diff --git a/.travis.yml b/.travis.yml
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
@@ -0,0 +1,19 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Development",
+      "type": "npm",
+      "script": "start",
+      "presentation": {
+        "clear": true,
+        "focus": false,
+        "panel": "shared",
+        "showReuseMessage": true
+      },
+      "runOptions": {
+        "runOn": "folderOpen"
+      }
+    }
+  ]
+}
diff --git a/LICENSE.md b/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright (c) 2014 Alexander Olsson
+Copyright (c) 2014-2021 Alexander Olsson, Jan T. Sott
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

diff --git a/README.md b/README.md
diff --git a/appveyor.yml b/appveyor.yml
diff --git a/keymaps/build.json b/keymaps/build.json
@@ -1,30 +1,30 @@
 {
   ".platform-darwin atom-workspace, .platform-darwin atom-text-editor": {
-    "cmd-alt-b": "build:trigger",
-    "cmd-alt-v": "build:toggle-panel",
-    "cmd-alt-g": "build:error-match",
-    "cmd-alt-h": "build:error-match-first",
-    "cmd-alt-t": "build:select-active-target"
+    "cmd-alt-b": "buildium:trigger",
+    "cmd-alt-v": "buildium:toggle-panel",
+    "cmd-alt-g": "buildium:error-match",
+    "cmd-alt-h": "buildium:error-match-first",
+    "cmd-alt-t": "buildium:select-active-target"
   },
   ".platform-linux atom-workspace, .platform-linux atom-text-editor, .platform-win32 atom-workspace, .platform-win32 atom-text-editor": {
-    "ctrl-alt-b": "build:trigger",
-    "ctrl-alt-v": "build:toggle-panel",
-    "ctrl-alt-g": "build:error-match",
-    "ctrl-alt-h": "build:error-match-first",
-    "ctrl-alt-t": "build:select-active-target"
+    "ctrl-alt-b": "buildium:trigger",
+    "ctrl-alt-v": "buildium:toggle-panel",
+    "ctrl-alt-g": "buildium:error-match",
+    "ctrl-alt-h": "buildium:error-match-first",
+    "ctrl-alt-t": "buildium:select-active-target"
   },
   "atom-workspace, atom-text-editor": {
-    "f9": "build:trigger",
-    "f8": "build:toggle-panel",
-    "f4": "build:error-match",
-    "shift-f4": "build:error-match-first",
-    "f7": "build:select-active-target"
+    "f9": "buildium:trigger",
+    "f8": "buildium:toggle-panel",
+    "f4": "buildium:error-match",
+    "shift-f4": "buildium:error-match-first",
+    "f7": "buildium:select-active-target"
   },
   ".build": {
-    "escape": "build:stop"
+    "escape": "buildium:stop"
   },
   ".build-confirm": {
-    "enter": "build:confirm",
-    "escape": "build:no-confirm"
+    "enter": "buildium:confirm",
+    "escape": "buildium:no-confirm"
   }
 }
diff --git a/lib/atom-build.js b/lib/atom-build.js
diff --git a/lib/build.js b/lib/build.js
diff --git a/lib/buildium.js b/lib/buildium.js
diff --git a/lib/config.js b/lib/config.js
diff --git a/lib/google-analytics.js b/lib/google-analytics.js
diff --git a/lib/linter-integration.js b/lib/linter-integration.js
diff --git a/lib/target-manager.js b/lib/target-manager.js
diff --git a/menus/build.json b/menus/build.json
@@ -1,30 +1,36 @@
 {
-  "menu": [ {
-    "label": "Packages",
-    "submenu": [ {
-        "label": "Build",
-        "submenu": [ {
-          "label": "Build project",
-          "command": "build:trigger"
-        },
+  "menu": [
+    {
+      "label": "Packages",
+      "submenu": [
         {
-          "label": "Terminate build",
-          "command": "build:stop"
-        },
-        {
-          "label": "Select active target",
-          "command": "build:select-active-target"
-        },
-        {
-          "label": "Refresh targets",
-          "command": "build:refresh-targets"
-        },
-        {
-          "label": "Toggle panel",
-          "command": "build:toggle-panel"
-        } ]
-      } ]
-  } ],
+          "label": "Buildium",
+          "submenu": [
+            {
+              "label": "Build project",
+              "command": "buildium:trigger"
+            },
+            {
+              "label": "Terminate build",
+              "command": "buildium:stop"
+            },
+            {
+              "label": "Select active target",
+              "command": "buildium:select-active-target"
+            },
+            {
+              "label": "Refresh targets",
+              "command": "buildium:refresh-targets"
+            },
+            {
+              "label": "Toggle panel",
+              "command": "buildium:toggle-panel"
+            }
+          ]
+        }
+      ]
+    }
+  ],
 
   "context-menu": {}
 }
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,34 +1,94 @@
 {
-  "name": "build",
-  "main": "./lib/build",
-  "version": "0.70.0",
+  "name": "buildium",
+  "version": "0.75.5",
   "description": "Build your current project, directly from Atom",
-  "repository": "https://github.com/noseglid/atom-build",
+  "keywords": [
+    "build",
+    "compile",
+    "gulp",
+    "make",
+    "productivity"
+  ],
+  "repository": "https://github.com/idleberg/atom-buildium",
   "license": "MIT",
-  "engines": {
-    "atom": ">=1.0.0"
+  "main": "./lib/buildium",
+  "scripts": {
+    "build": "npm run clean && rollup --config",
+    "dev": "npm run start",
+    "clean": "rimraf ./lib",
+    "format": "prettier --write ./src ./styles",
+    "lint:js": "eslint ./src --ignore-path .gitignore",
+    "lint:md": "remark . --quiet --frail --ignore-path .gitignore",
+    "lint": "npm-run-all --parallel lint:*",
+    "start": "rollup --watch --config",
+    "test": "eslint .",
+    "prepare": "husky install"
+  },
+  "lint-staged": {
+    "*.js": [
+      "eslint --cache --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,less}": "prettier --write"
   },
   "dependencies": {
-    "atom-package-deps": "^4.0.1",
+    "@atxm/developer-console": "^0.5.0",
+    "@iarna/toml": "^2.2.5",
+    "atom-package-deps": "^7.2.2",
     "atom-space-pen-views": "^2.0.3",
-    "cross-spawn": "^4.0.2",
-    "cson-parser": "^1.3.0",
-    "getmac": "^1.0.7",
-    "js-yaml": "^3.4.6",
-    "term.js": "https://github.com/jeremyramin/term.js/tarball/de1635fc2695e7d8165012d3b1d007d7ce60eea2",
+    "core-js": "^3.15.2",
+    "cosmiconfig": "^7.0.0",
+    "cross-spawn": "^7.0.3",
+    "cson-parser": "^4.0.8",
+    "js-yaml": "^4.0.0",
+    "json5": "^2.2.0",
     "tree-kill": "^1.0.0",
-    "xregexp": "^3.1.0"
+    "xregexp": "^5.0.1",
+    "xterm": "^2.9.2"
   },
   "devDependencies": {
+    "@babel/core": "^7.14.3",
+    "@babel/eslint-parser": "^7.14.7",
+    "@babel/preset-env": "^7.14.7",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^19.0.1",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.0.2",
+    "@stylelint/prettier-config": "^2.0.0",
+    "@stylelint/remark-preset": "^2.0.0",
     "atom-build-spec-helpers": "^0.4.0",
-    "babel-eslint": "^6.0.0",
-    "eslint": "^2.10.1",
-    "eslint-config-atom-build": "^3.0.0",
-    "fs-extra": "^2.1.2",
-    "temp": "^0.8.1"
+    "eslint": "^7.31.0",
+    "husky": "^7.0.0",
+    "jsonlint": "^1.6.3",
+    "lint-staged": "^11.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "remark-cli": "^9.0.0",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.53.2",
+    "rollup-plugin-terser": "^7.0.2",
+    "sass": "^1.35.2",
+    "stylelint": "^13.13.1",
+    "temp": "^0.9.4"
   },
-  "package-deps": [
-    "busy-signal"
+  "engines": {
+    "atom": ">=1.0.0"
+  },
+  "activationCommands": {
+    "atom-workspace": [
+      "build:confirm",
+      "build:error-match-first",
+      "build:error-match",
+      "build:no-confirm",
+      "build:refresh-targets",
+      "build:select-active-target",
+      "build:stop",
+      "build:toggle-panel",
+      "build:trigger"
+    ]
+  },
+  "activationHooks": [
+    "core:loaded-shell-environment"
   ],
   "consumedServices": {
     "builder": {
@@ -52,14 +112,9 @@
       }
     }
   },
-  "scripts": {
-    "test": "eslint ."
-  },
-  "keywords": [
-    "build",
-    "compile",
-    "gulp",
-    "make",
-    "productivity"
+  "package-deps": [
+    {
+      "name": "busy-signal"
+    }
   ]
 }
diff --git a/rollup.config.mjs b/rollup.config.mjs
@@ -0,0 +1,41 @@
+import { babel } from '@rollup/plugin-babel';
+import { terser } from "rollup-plugin-terser";
+import commonjs from '@rollup/plugin-commonjs';
+import json from '@rollup/plugin-json';
+
+const plugins = [
+  babel({
+    babelHelpers: 'bundled'
+  }),
+  commonjs(),
+  json(),
+  (
+    process.env.ROLLUP_WATCH
+      ? undefined
+      : terser()
+  )
+];
+
+export default [
+  {
+    input: 'src/buildium.js',
+    output: {
+      dir: 'lib',
+      exports: 'default',
+      format: 'cjs',
+      sourcemap: process.env.ROLLUP_WATCH ? true : false
+    },
+    external: [
+      // Atom
+      'atom',
+      'electron',
+
+      // Node
+      'child_process',
+      'fs',
+      'os',
+      'path'
+    ],
+    plugins: plugins
+  }
+];
diff --git a/spec/.eslintrc b/spec/.eslintrc
diff --git a/spec/build-atomCommandName-spec.js b/spec/build-atomCommandName-spec.js
diff --git a/spec/build-confirm-spec.js b/spec/build-confirm-spec.js
diff --git a/spec/build-error-match-spec.js b/spec/build-error-match-spec.js
diff --git a/spec/build-hooks-spec.js b/spec/build-hooks-spec.js
diff --git a/spec/build-keymap-spec.js b/spec/build-keymap-spec.js
diff --git a/spec/build-spec.js b/spec/build-spec.js
diff --git a/spec/build-targets-spec.js b/spec/build-targets-spec.js
diff --git a/spec/build-view-spec.js b/spec/build-view-spec.js
diff --git a/spec/build-visible-spec.js b/spec/build-visible-spec.js
diff --git a/spec/custom-provider-spec.js b/spec/custom-provider-spec.js
diff --git a/spec/fixture/.atom-build.cson b/spec/fixture/.atom-build.cson
diff --git a/spec/fixture/.atom-build.error-match-function.js b/spec/fixture/.atom-build.error-match-function.js
diff --git a/spec/fixture/.atom-build.error-match-long-output.json b/spec/fixture/.atom-build.error-match-long-output.json
diff --git a/spec/fixture/.atom-build.error-match-multiple-errorMatch.json b/spec/fixture/.atom-build.error-match-multiple-errorMatch.json
diff --git a/spec/fixture/.atom-build.error-match-multiple-first.json b/spec/fixture/.atom-build.error-match-multiple-first.json
diff --git a/spec/fixture/.atom-build.error-match-multiple.json b/spec/fixture/.atom-build.error-match-multiple.json
diff --git a/spec/fixture/.atom-build.error-match-no-exit1.json b/spec/fixture/.atom-build.error-match-no-exit1.json
diff --git a/spec/fixture/.atom-build.error-match-no-file.json b/spec/fixture/.atom-build.error-match-no-file.json
diff --git a/spec/fixture/.atom-build.error-match-no-line-col.json b/spec/fixture/.atom-build.error-match-no-line-col.json
diff --git a/spec/fixture/.atom-build.error-match.json b/spec/fixture/.atom-build.error-match.json
diff --git a/spec/fixture/.atom-build.error-match.message.json b/spec/fixture/.atom-build.error-match.message.json
diff --git a/spec/fixture/.atom-build.js b/spec/fixture/.atom-build.js
diff --git a/spec/fixture/.atom-build.json b/spec/fixture/.atom-build.json
diff --git a/spec/fixture/.atom-build.match-function-change-dirs.js b/spec/fixture/.atom-build.match-function-change-dirs.js
diff --git a/spec/fixture/.atom-build.match-function-html.js b/spec/fixture/.atom-build.match-function-html.js
diff --git a/spec/fixture/.atom-build.match-function-message-and-html.js b/spec/fixture/.atom-build.match-function-message-and-html.js
diff --git a/spec/fixture/.atom-build.match-function-trace-html.js b/spec/fixture/.atom-build.match-function-trace-html.js
diff --git a/spec/fixture/.atom-build.match-function-trace-message-and-html.js b/spec/fixture/.atom-build.match-function-trace-message-and-html.js
diff --git a/spec/fixture/.atom-build.match-function-trace.js b/spec/fixture/.atom-build.match-function-trace.js
diff --git a/spec/fixture/.atom-build.match-function-warning.js b/spec/fixture/.atom-build.match-function-warning.js
diff --git a/spec/fixture/.atom-build.replace.json b/spec/fixture/.atom-build.replace.json
diff --git a/spec/fixture/.atom-build.sh-default.json b/spec/fixture/.atom-build.sh-default.json
@@ -0,0 +1,98 @@
+import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
+import EventEmitter from 'events';
+import fs from 'fs';
+import loaders from './loaders';
+import os from 'os';
+import path from 'path';
+import pkg from '../package.json';
+
+const explorer = cosmiconfig(pkg.name, {
+  searchPlaces: ['.atom-build.cjs', '.atom-build.js', '.atom-build.json', '.atom-build.json5', '.atom-build.toml', '.atom-build.yaml', '.atom-build.yml'],
+  loaders: {
+    '.cson': loaders.cson,
+    '.toml': loaders.toml,
+    '.json': loaders.json5,
+    '.json5': loaders.json5,
+    'noExt': defaultLoaders['.json']
+  }
+});
+
+async function getConfig(file) {
+  const realFile = await fs.promises.realpath(file);
+
+  return (await explorer.load(realFile)).config || {};
+}
+
+function createBuildConfig(build, name) {
+  const conf = {
+    name: 'Custom: ' + name,
+    exec: build.cmd,
+    env: build.env,
+    args: build.args,
+    cwd: build.cwd,
+    sh: build.sh,
+    errorMatch: build.errorMatch,
+    functionMatch: build.functionMatch,
+    warningMatch: build.warningMatch,
+    atomCommandName: build.atomCommandName,
+    keymap: build.keymap,
+    killSignals: build.killSignals
+  };
+
+  if (typeof build.postBuild === 'function') {
+    conf.postBuild = build.postBuild;
+  }
+
+  if (typeof build.preBuild === 'function') {
+    conf.preBuild = build.preBuild;
+  }
+
+  return conf;
+}
+
+export default class CustomFile extends EventEmitter {
+  constructor(cwd) {
+    super();
+    this.cwd = cwd;
+    this.fileWatchers = [];
+  }
+
+  destructor() {
+    this.fileWatchers.map((fw) => fw.close());
+  }
+
+  getNiceName() {
+    return 'Custom file';
+  }
+
+  isEligible() {
+    this.files = [].concat
+      .apply(
+        [],
+        ['cjs', 'js', 'json', 'json5', 'cson', , 'toml', 'yaml', 'yml'].map((ext) => [
+          path.join(this.cwd, `.atom-build.${ext}`),
+          path.join(os.homedir(), `.atom-build.${ext}`)
+        ])
+      )
+      .filter(fs.existsSync);
+    return 0 < this.files.length;
+  }
+
+  async settings() {
+    this.fileWatchers.map((fw) => fw.close());
+    // On Linux, closing a watcher triggers a new callback, which causes an infinite loop
+    // fallback to `watchFile` here which polls instead.
+    this.fileWatchers = this.files.map((file) => (os.platform() === 'linux' ? fs.watchFile : fs.watch)(file, () => this.emit('refresh')));
+
+    const config = [];
+    const buildConfigs = await Promise.all(this.files.map(async (file) => await getConfig(file)));
+    buildConfigs.map((build) => {
+      config.push(
+        createBuildConfig(build, build.name || 'default'),
+        ...Object.keys(build.targets || {}).map((name) => createBuildConfig(build.targets[name], name))
+      );
+    });
+
+    return config;
+  }
+}
@@ -1,5 +1,3 @@
-'use babel';
-
 export default class BuildError extends Error {
   constructor(name, message) {
     super(message);

@@ -1,29 +1,50 @@
-'use babel';
-
+import { capitalizedName, getVersion } from './utils';
 import { View, $ } from 'atom-space-pen-views';
+import Config from './config';
+import Terminal from 'xterm';
 
 export default class BuildView extends View {
-
   static initialTimerText() {
-    return '0.0 s';
+    return '0.000 s';
   }
 
   static initialHeadingText() {
-    return 'Atom Build';
+    return `${capitalizedName()} ${getVersion()}`;
   }
 
   static content() {
     this.div({ tabIndex: -1, class: 'build tool-panel native-key-bindings' }, () => {
       this.div({ class: 'heading', outlet: 'panelHeading' }, () => {
-        this.div({ class: 'control-container opaque-hover' }, () => {
-          this.button({ class: 'btn btn-default icon icon-zap', click: 'build', title: 'Build current project' });
-          this.button({ class: 'btn btn-default icon icon-trashcan', click: 'clearOutput' });
-          this.button({ class: 'btn btn-default icon icon-x', click: 'close' });
+        this.div({ class: 'control-container' }, () => {
+          this.button(
+            {
+              class: 'btn btn-default icon icon-zap',
+              click: 'build',
+              title: 'Builds current project'
+            },
+            'Build'
+          );
+          this.button(
+            {
+              class: 'btn btn-default icon icon-trashcan',
+              click: 'clearOutput',
+              title: 'Clears the output'
+            },
+            'Clear'
+          );
+          this.button(
+            {
+              class: 'btn btn-default icon icon-x',
+              click: 'close',
+              title: 'Closes the build panel'
+            },
+            'Close'
+          );
           this.div({ class: 'title', outlet: 'title' }, () => {
             this.span({ class: 'build-timer', outlet: 'buildTimer' }, this.initialTimerText());
           });
         });
-        this.div({ class: 'icon heading-text', outlet: 'heading' }, this.initialHeadingText());
+        this.div({ class: 'icon heading-text text-highlight', outlet: 'heading' }, this.initialHeadingText());
       });
 
       this.div({ class: 'output panel-body', outlet: 'output' });
@@ -33,19 +54,18 @@ export default class BuildView extends View {
 
   constructor(...args) {
     super(...args);
-    const Terminal = require('term.js');
     this.starttime = new Date();
     this.terminal = new Terminal({
       cursorBlink: false,
       convertEol: true,
       useFocus: false,
       termName: 'xterm-256color',
-      scrollback: atom.config.get('build.terminalScrollback')
+      scrollback: Config.get('terminalScrollback')
     });
 
     // On some systems, prependListern and prependOnceListener is expected to exist. Add them until terminal replacement is here.
     this.terminal.prependListener = (...a) => {
-      this.terminal.addListener(...a);
+      this.terminal.on(...a);
     };
     this.terminal.prependOnceListener = (...a) => {
       this.terminal.addOnceListener(...a);
@@ -59,27 +79,20 @@ export default class BuildView extends View {
 
     this.fontGeometry = { w: 15, h: 15 };
     this.terminal.open(this.output[0]);
-    this.destroyTerminal = ::(this.terminal).destroy;
+    this.destroyTerminal = this.terminal.destroy.bind(this);
     this.terminal.destroy = this.terminal.destroySoon = () => {}; // This terminal will be open forever and reset when necessary
     this.terminalEl = $(this.terminal.element);
     this.terminalEl[0].terminal = this.terminal; // For testing purposes
 
-    this.resizeStarted = ::this.resizeStarted;
-    this.resizeMoved = ::this.resizeMoved;
-    this.resizeEnded = ::this.resizeEnded;
+    this.resizeStarted = this.resizeStarted.bind(this);
+    this.resizeMoved = this.resizeMoved.bind(this);
+    this.resizeEnded = this.resizeEnded.bind(this);
 
-    atom.config.observe('build.panelVisibility', ::this.visibleFromConfig);
-    atom.config.observe('build.panelOrientation', ::this.orientationFromConfig);
-    atom.config.observe('build.hidePanelHeading', (hide) => {
-      hide && this.panelHeading.hide() || this.panelHeading.show();
-    });
-    atom.config.observe('build.overrideThemeColors', (override) => {
-      this.output.removeClass('override-theme');
-      override && this.output.addClass('override-theme');
-    });
-    atom.config.observe('editor.fontSize', ::this.fontSizeFromConfig);
-    atom.config.observe('editor.fontFamily', ::this.fontFamilyFromConfig);
-    atom.commands.add('atom-workspace', 'build:toggle-panel', ::this.toggle);
+    Config.observe('panelVisibility', this.visibleFromConfig.bind(this));
+    Config.observe('panelOrientation', this.orientationFromConfig.bind(this));
+    atom.config.observe('editor.fontSize', this.fontSizeFromConfig.bind(this));
+    atom.config.observe('editor.fontFamily', this.fontFamilyFromConfig.bind(this));
+    atom.commands.add('atom-workspace', 'buildium:toggle-panel', this.toggle.bind(this));
   }
 
   destroy() {
@@ -96,10 +109,10 @@ export default class BuildView extends View {
   resizeMoved(ev) {
     const { h } = this.fontGeometry;
 
-    switch (atom.config.get('build.panelOrientation')) {
+    switch (Config.get('panelOrientation')) {
       case 'Bottom': {
         const delta = this.resizer.get(0).getBoundingClientRect().top - ev.y;
-        if (Math.abs(delta) < (h * 5 / 6)) return;
+        if (Math.abs(delta) < (h * 5) / 6) return;
 
         const nearestRowHeight = Math.round((this.terminalEl.height() + delta) / h) * h;
         const maxHeight = $('.item-views').height() + $('.build .output').height();
@@ -109,7 +122,7 @@ export default class BuildView extends View {
 
       case 'Top': {
         const delta = this.resizer.get(0).getBoundingClientRect().top - ev.y;
-        if (Math.abs(delta) < (h * 5 / 6)) return;
+        if (Math.abs(delta) < (h * 5) / 6) return;
 
         const nearestRowHeight = Math.round((this.terminalEl.height() - delta) / h) * h;
         const maxHeight = $('.item-views').height() + $('.build .output').height();
@@ -140,17 +153,14 @@ export default class BuildView extends View {
   }
 
   resizeToNearestRow() {
-    if (-1 !== [ 'Top', 'Bottom' ].indexOf(atom.config.get('build.panelOrientation'))) {
+    if (-1 !== ['Top', 'Bottom'].indexOf(Config.get('panelOrientation'))) {
       this.fixTerminalElHeight();
     }
     this.resizeTerminal();
   }
 
   getFontGeometry() {
-    const o = $('<div>A</div>')
-      .addClass('terminal')
-      .addClass('terminal-test')
-      .appendTo(this.output);
+    const o = $('<div>A</div>').addClass('terminal').addClass('terminal-test').appendTo(this.output);
     const w = o[0].getBoundingClientRect().width;
     const h = o[0].getBoundingClientRect().height;
     o.remove();
@@ -164,8 +174,8 @@ export default class BuildView extends View {
       return;
     }
 
-    const terminalWidth = Math.floor((this.terminalEl.width()) / w);
-    const terminalHeight = Math.floor((this.terminalEl.height()) / h);
+    const terminalWidth = Math.floor(this.terminalEl.width() / w);
+    const terminalHeight = Math.floor(this.terminalEl.height() / h);
 
     this.terminal.resize(terminalWidth, terminalHeight);
   }
@@ -176,7 +186,7 @@ export default class BuildView extends View {
 
   attach(force = false) {
     if (!force) {
-      switch (atom.config.get('build.panelVisibility')) {
+      switch (Config.get('panelVisibility')) {
         case 'Hidden':
         case 'Show on Error':
           return;
@@ -193,7 +203,7 @@ export default class BuildView extends View {
       Left: atom.workspace.addLeftPanel,
       Right: atom.workspace.addRightPanel
     };
-    const orientation = atom.config.get('build.panelOrientation') || 'Bottom';
+    const orientation = Config.get('panelOrientation') || 'Bottom';
     this.panel = addfn[orientation].call(atom.workspace, { item: this });
     this.fixTerminalElHeight();
     this.resizeToNearestRow();
@@ -209,7 +219,7 @@ export default class BuildView extends View {
     if (atom.views.getView(atom.workspace) && document.activeElement === this[0]) {
       atom.views.getView(atom.workspace).focus();
     }
-    if (this.panel && (force || 'Keep Visible' !== atom.config.get('build.panelVisibility'))) {
+    if (this.panel && (force || 'Keep Visible' !== Config.get('panelVisibility'))) {
       this.panel.destroy();
       this.panel = null;
     }
@@ -281,7 +291,7 @@ export default class BuildView extends View {
   }
 
   updateTitle() {
-    this.buildTimer.text(((new Date() - this.starttime) / 1000).toFixed(1) + ' s');
+    this.buildTimer.text(((new Date() - this.starttime) / 1000).toFixed(3) + ' s');
     this.titleTimer = setTimeout(this.updateTitle.bind(this), 100);
   }
 
@@ -290,7 +300,6 @@ export default class BuildView extends View {
   }
 
   toggle() {
-    require('./google-analytics').sendEvent('view', 'panel toggled');
     this.isAttached() ? this.detach(true) : this.attach(true);
   }
 
@@ -299,7 +308,7 @@ export default class BuildView extends View {
   }
 
   build() {
-    atom.commands.dispatch(atom.views.getView(atom.workspace), 'build:trigger');
+    atom.commands.dispatch(atom.views.getView(atom.workspace), 'buildium:trigger');
   }
 
   setHeading(heading) {
@@ -310,15 +319,15 @@ export default class BuildView extends View {
     this.starttime = new Date();
     this.reset();
     this.attach();
-    if (atom.config.get('build.stealFocus')) {
+    if (Config.get('stealFocus')) {
       this.focus();
     }
     this.updateTitle();
   }
 
   buildFinished(success) {
     if (!success && !this.isAttached()) {
-      this.attach(atom.config.get('build.panelVisibility') === 'Show on Error');
+      this.attach(Config.get('panelVisibility') === 'Show on Error');
     }
     this.finalizeBuild(success);
   }

@@ -0,0 +1,183 @@
+import { name } from '../package.json';
+
+export default {
+  schema: {
+    panelVisibility: {
+      title: 'Panel Visibility',
+      description: 'Set when the build panel should be visible.',
+      type: 'string',
+      default: 'Toggle',
+      enum: ['Toggle', 'Keep Visible', 'Show on Error', 'Hidden'],
+      order: 1
+    },
+    autoToggleInterval: {
+      title: 'Auto-toggle Interval',
+      description: 'Set the interval until the panel closes automatically, in milliseconds. This setting works with *Panel Visibility* set to *Toggle*',
+      type: 'integer',
+      minimum: 1000,
+      default: 3000,
+      order: 2
+    },
+    buildOnSave: {
+      title: 'Automatically build on save',
+      description: 'Automatically build your project each time an editor is saved.',
+      type: 'boolean',
+      default: false,
+      order: 3
+    },
+    saveOnBuild: {
+      title: 'Automatically save on build',
+      description: 'Automatically save all edited files when triggering a build.',
+      type: 'boolean',
+      default: false,
+      order: 4
+    },
+    matchedErrorFailsBuild: {
+      title: 'Any matched error will fail the build',
+      description: 'Even if the build has a return code of zero it is marked as "failed" if any error is being matched in the output.',
+      type: 'boolean',
+      default: true,
+      order: 5
+    },
+    scrollOnError: {
+      title: 'Automatically scroll on build error',
+      description: 'Automatically scroll to first matched error when a build failed.',
+      type: 'boolean',
+      default: false,
+      order: 6
+    },
+    stealFocus: {
+      title: 'Steal Focus',
+      description: 'Steal focus when opening build panel.',
+      type: 'boolean',
+      default: true,
+      order: 7
+    },
+    selectTriggers: {
+      title: 'Selecting new target triggers the build',
+      description: 'When selecting a new target (through status-bar, cmd-alt-t, etc), the newly selected target will be triggered.',
+      type: 'boolean',
+      default: true,
+      order: 9
+    },
+    refreshOnShowTargetList: {
+      title: 'Refresh targets when the target list is shown',
+      description: 'When opening the targets menu, the targets will be refreshed.',
+      type: 'boolean',
+      default: false,
+      order: 10
+    },
+    notificationOnRefresh: {
+      title: 'Show notification when targets are refreshed',
+      description: 'When targets are refreshed a notification with information about the number of targets will be displayed.',
+      type: 'boolean',
+      default: false,
+      order: 11
+    },
+    beepWhenDone: {
+      title: 'Beep when the build completes',
+      description: 'Make a "beep" notification sound when the build is complete - in success or failure.',
+      type: 'boolean',
+      default: false,
+      order: 12
+    },
+    panelOrientation: {
+      title: 'Panel Orientation',
+      description: 'Where to attach the build panel',
+      type: 'string',
+      default: 'Bottom',
+      enum: ['Bottom', 'Top', 'Left', 'Right'],
+      order: 13
+    },
+    statusBar: {
+      title: 'Status Bar',
+      description: 'Where to place the status bar. Set to `Disable` to disable status bar display.',
+      type: 'string',
+      default: 'Left',
+      enum: ['Left', 'Right', 'Disable'],
+      order: 14
+    },
+    statusBarPriority: {
+      title: 'Priority on Status Bar',
+      description: 'Lower priority tiles are placed further to the left/right, depends on where you choose to place Status Bar.',
+      type: 'integer',
+      default: -1000,
+      order: 15
+    },
+    terminalScrollback: {
+      title: 'Terminal Scrollback Size',
+      description: 'Max number of lines of build log kept in the terminal',
+      type: 'integer',
+      default: 1000,
+      order: 16
+    },
+    muteConflictWarning: {
+      title: 'Mute Conflict Warning',
+      description: 'Disables the startup dialog, whether the user wants to disable the original `build` package',
+      type: 'boolean',
+      default: false,
+      order: 17
+    }
+  },
+
+  get(key = '') {
+    return key?.length ? atom.config.get(`${name}.${key}`) : atom.config.get(`${name}`);
+  },
+
+  set(key, value) {
+    atom.config.set(`${name}.${key}`, value);
+  },
+
+  migrate(oldKey, newKey) {
+    if (!atom.config.get(`${name}.${oldKey}`) || atom.config.get(`${name}.${newKey}`)) {
+      return;
+    }
+
+    try {
+      atom.config.set(`${name}.${newKey}`, atom.config.get(`${name}.${oldKey}`));
+    } catch (error) {
+      atom.notifications.addWarning(`Failed to migrate configuration, see console for details`);
+
+      return;
+    }
+
+    atom.config.unset(`${name}.${oldKey}`);
+  },
+
+  observe(...args) {
+    let key, options, callback;
+
+    switch (args.length) {
+      case 2:
+        [key, callback] = args;
+        options = {};
+        break;
+
+      case 3:
+        [keyPath, options, callback] = args;
+        break;
+
+      default:
+        console.error('An unsupported form of Config::observe is being used. See https://atom.io/docs/api/latest/Config for details');
+        return;
+    }
+
+    atom.config.observe(`${name}.${key}`, options, callback);
+  },
+
+  unset(key = '') {
+    const unsetKey = key?.length ? `${name}.${key}` : name;
+
+    atom.config.unset(unsetKey);
+  },
+
+  open(options = {}) {
+    options = {
+      pending: true,
+      searchAllPanes: true,
+      ...options
+    };
+
+    atom.workspace.open(`atom://config/packages/${name}`, options);
+  }
+};
@@ -1,9 +1,9 @@
-'use babel';
-
 import { EventEmitter } from 'events';
+import fs from 'fs';
+import path from 'path';
+import XRegExp from 'xregexp';
 
 export default class ErrorMatcher extends EventEmitter {
-
   constructor() {
     super();
     this.regex = null;
@@ -13,8 +13,8 @@ export default class ErrorMatcher extends EventEmitter {
     this.currentMatch = [];
     this.firstMatchId = null;
 
-    atom.commands.add('atom-workspace', 'build:error-match', ::this.match);
-    atom.commands.add('atom-workspace', 'build:error-match-first', ::this.matchFirst);
+    atom.commands.add('atom-workspace', 'buildium:error-match', this.match.bind(this));
+    atom.commands.add('atom-workspace', 'buildium:error-match-first', this.matchFirst.bind(this));
   }
 
   _gotoNext() {
@@ -26,9 +26,9 @@ export default class ErrorMatcher extends EventEmitter {
   }
 
   goto(id) {
-    const match = this.currentMatch.find(m => m.id === id);
+    const match = this.currentMatch.find((m) => m.id === id);
     if (!match) {
-      this.emit('error', 'Can\'t find match with id ' + id);
+      this.emit('error', "Can't find match with id " + id);
       return;
     }
 
@@ -40,19 +40,18 @@ export default class ErrorMatcher extends EventEmitter {
 
     let file = match.file;
     if (!file) {
-      this.emit('error', 'Did not match any file. Don\'t know what to open.');
+      this.emit('error', "Did not match any file. Don't know what to open.");
       return;
     }
 
-    const path = require('path');
     if (!path.isAbsolute(file)) {
       file = this.cwd + path.sep + file;
     }
 
     const row = match.line ? match.line - 1 : 0; /* Because atom is zero-based */
     const col = match.col ? match.col - 1 : 0; /* Because atom is zero-based */
 
-    require('fs').exists(file, (exists) => {
+    fs.exists(file, (exists) => {
       if (!exists) {
         this.emit('error', 'Matched file does not exist: ' + file);
         return;
@@ -70,37 +69,41 @@ export default class ErrorMatcher extends EventEmitter {
     this.currentMatch = [];
 
     // first run all functional matches
-    this.functions && this.functions.forEach((f, functionIndex) => {
-      this.currentMatch = this.currentMatch.concat(f(this.output).map((match, matchIndex) => {
-        match.id = 'error-match-function-' + functionIndex + '-' + matchIndex;
-        match.type = match.type || 'Error';
-        return match;
-      }));
-    });
+    this.functions &&
+      this.functions.forEach((f, functionIndex) => {
+        this.currentMatch = this.currentMatch.concat(
+          f(this.output).map((match, matchIndex) => {
+            match.id = 'error-match-function-' + functionIndex + '-' + matchIndex;
+            match.type = match.type || 'Error';
+            return match;
+          })
+        );
+      });
     // then for all match kinds
-    Object.keys(this.regex).forEach(kind => {
+    Object.keys(this.regex).forEach((kind) => {
       // run all matches
-      this.regex[kind] && this.regex[kind].forEach((regex, i) => {
-        regex && require('xregexp').forEach(this.output, regex, (match, matchIndex) => {
-          match.id = 'error-match-' + i + '-' + matchIndex;
-          match.type = kind;
-          this.currentMatch.push(match);
+      this.regex[kind] &&
+        this.regex[kind].forEach((regex, i) => {
+          regex &&
+            XRegExp.forEach(this.output, regex, (match, matchIndex) => {
+              match.id = 'error-match-' + i + '-' + matchIndex;
+              match.type = kind;
+              this.currentMatch.push(match);
+            });
         });
-      });
     });
 
     this.currentMatch.sort((a, b) => a.index - b.index);
 
-    this.firstMatchId = (this.currentMatch.length > 0) ? this.currentMatch[0].id : null;
+    this.firstMatchId = this.currentMatch.length > 0 ? this.currentMatch[0].id : null;
   }
 
   _prepareRegex(regex) {
     regex = regex || [];
-    regex = (regex instanceof Array) ? regex : [ regex ];
+    regex = regex instanceof Array ? regex : [regex];
 
-    return regex.map(r => {
+    return regex.map((r) => {
       try {
-        const XRegExp = require('xregexp');
         return XRegExp(r);
       } catch (err) {
         this.emit('error', 'Error parsing regex. ' + err.message);
@@ -111,7 +114,7 @@ export default class ErrorMatcher extends EventEmitter {
 
   set(target, cwd, output) {
     if (target.functionMatch) {
-      this.functions = ((target.functionMatch instanceof Array) ? target.functionMatch : [ target.functionMatch ]).filter(f => {
+      this.functions = (target.functionMatch instanceof Array ? target.functionMatch : [target.functionMatch]).filter((f) => {
         if (typeof f !== 'function') {
           this.emit('error', 'found functionMatch that is no function: ' + typeof f);
           return false;
@@ -132,14 +135,10 @@ export default class ErrorMatcher extends EventEmitter {
   }
 
   match() {
-    require('./google-analytics').sendEvent('errorMatch', 'match');
-
     this._gotoNext();
   }
 
   matchFirst() {
-    require('./google-analytics').sendEvent('errorMatch', 'first');
-
     if (this.firstMatchId) {
       this.goto(this.firstMatchId);
     }

@@ -0,0 +1,58 @@
+import path from 'path';
+
+class Linter {
+  constructor(registry) {
+    this.linter = registry.register({ name: 'Build' });
+  }
+  destroy() {
+    this.linter.dispose();
+  }
+  clear() {
+    this.linter.deleteMessages();
+  }
+  processMessages(messages, cwd) {
+    function extractRange(json) {
+      return [
+        [(json.line || 1) - 1, (json.col || 1) - 1],
+        [(json.line_end || json.line || 1) - 1, (json.col_end || json.col || 1) - 1]
+      ];
+    }
+    function normalizePath(p) {
+      return path.isAbsolute(p) ? p : path.join(cwd, p);
+    }
+    function typeToSeverity(type) {
+      switch (type && type.toLowerCase()) {
+        case 'err':
+        case 'error':
+          return 'error';
+        case 'warn':
+        case 'warning':
+          return 'warning';
+        default:
+          return null;
+      }
+    }
+    this.linter.setMessages(
+      messages.map((match) => ({
+        type: match.type || 'Error',
+        text: !match.message && !match.html_message ? 'Error from build' : match.message,
+        html: match.message ? undefined : match.html_message,
+        filePath: normalizePath(match.file),
+        severity: typeToSeverity(match.type),
+        range: extractRange(match),
+        trace:
+          match.trace &&
+          match.trace.map((trace) => ({
+            type: trace.type || 'Trace',
+            text: !trace.message && !trace.html_message ? 'Trace in build' : trace.message,
+            html: trace.message ? undefined : trace.html_message,
+            filePath: trace.file && normalizePath(trace.file),
+            severity: typeToSeverity(trace.type) || 'info',
+            range: extractRange(trace)
+          }))
+      }))
+    );
+  }
+}
+
+export default Linter;
@@ -0,0 +1,32 @@
+import CSON from 'cson-parser';
+import TOML from '@iarna/toml';
+import JSON5 from 'json5';
+
+export default {
+  cson(filePath, content) {
+    try {
+      return CSON.parse(content);
+    } catch (error) {
+      error.message = `TOML Error in ${filePath}:\n${error.message}`;
+      throw error;
+    }
+  },
+
+  json5(filePath, content) {
+    try {
+      return JSON5.parse(content);
+    } catch (error) {
+      error.message = `TOML Error in ${filePath}:\n${error.message}`;
+      throw error;
+    }
+  },
+
+  toml(filePath, content) {
+    try {
+      return TOML.parse(content);
+    } catch (error) {
+      error.message = `TOML Error in ${filePath}:\n${error.message}`;
+      throw error;
+    }
+  }
+};
@@ -0,0 +1,43 @@
+import { name } from '../package.json';
+
+const styleSheet = `
+  background-color: darkslateblue;
+  border-radius: 2px;
+  color: white;
+  line-height: 1.5;
+  padding: 1px 4px;
+  text-shadow: 0 1px 0px rgba(0, 0, 0, 0.2);
+`;
+
+function __console__(type, ...args) {
+  if (!atom?.inDevMode()) return;
+
+  args.unshift(`%c${name}%c`, styleSheet, '');
+  window.console[type](...args);
+}
+
+export default {
+  debug(...data) {
+    __console__('debug', ...data);
+  },
+
+  error(...data) {
+    __console__('error', ...data);
+  },
+
+  info(...data) {
+    __console__('info', ...data);
+  },
+
+  log(...data) {
+    __console__('log', ...data);
+  },
+
+  trace(...data) {
+    __console__('trace', ...data);
+  },
+
+  warn(...data) {
+    __console__('warn', ...data);
+  }
+};
@@ -1,17 +1,30 @@
-'use babel';
-
 import { View } from 'atom-space-pen-views';
 
 export default class SaveConfirmView extends View {
   static content() {
     this.div({ class: 'build-confirm overlay from-top' }, () => {
       this.h3('You have unsaved changes');
       this.div({ class: 'btn-container pull-right' }, () => {
-        this.button({ class: 'btn btn-success', outlet: 'saveBuildButton', title: 'Save and Build', click: 'saveAndConfirm' }, 'Save and build');
-        this.button({ class: 'btn btn-info', title: 'Build Without Saving', click: 'confirmWithoutSave' }, 'Build Without Saving');
+        this.button(
+          {
+            class: 'btn btn-primary',
+            outlet: 'saveBuildButton',
+            title: 'Save and Build',
+            click: 'saveAndConfirm'
+          },
+          'Save and build'
+        );
+        this.button(
+          {
+            class: 'btn btn-primary',
+            title: 'Build without Saving',
+            click: 'confirmWithoutSave'
+          },
+          'Build without Saving'
+        );
       });
       this.div({ class: 'btn-container pull-left' }, () => {
-        this.button({ class: 'btn btn-info', title: 'Cancel', click: 'cancel' }, 'Cancel');
+        this.button({ class: 'btn', title: 'Cancel', click: 'cancel' }, 'Cancel');
       });
     });
   }

@@ -1,26 +1,25 @@
-'use babel';
-
 import { View } from 'atom-space-pen-views';
+import Config from './config';
 
 export default class StatusBarView extends View {
   constructor(statusBar, ...args) {
     super(...args);
     this.statusBar = statusBar;
-    atom.config.observe('build.statusBar', () => this.attach());
-    atom.config.observe('build.statusBarPriority', () => this.attach());
+    Config.observe('statusBar', () => this.attach());
+    Config.observe('statusBarPriority', () => this.attach());
   }
 
   attach() {
     this.destroy();
 
-    const orientation = atom.config.get('build.statusBar');
+    const orientation = Config.get('statusBar');
     if ('Disable' === orientation) {
       return;
     }
 
     this.statusBarTile = this.statusBar[`add${orientation}Tile`]({
       item: this,
-      priority: atom.config.get('build.statusBarPriority')
+      priority: Config.get('statusBarPriority')
     });
 
     this.tooltip = atom.tooltips.add(this, {
@@ -42,7 +41,7 @@ export default class StatusBarView extends View {
 
   static content() {
     this.div({ id: 'build-status-bar', class: 'inline-block' }, () => {
-      this.a({ click: 'clicked', outlet: 'message'});
+      this.a({ click: 'clicked', outlet: 'message' });
     });
   }
 

@@ -0,0 +1,254 @@
+import { CompositeDisposable } from 'atom';
+import * as Utils from './utils';
+import Config from './config';
+import DevConsole from './log';
+import EventEmitter from 'events';
+import TargetsView from './targets-view';
+
+class TargetManager extends EventEmitter {
+  constructor() {
+    super();
+
+    let projectPaths = atom.project.getPaths();
+
+    this.pathTargets = projectPaths.map((path) => this._defaultPathTarget(path));
+
+    atom.project.onDidChangePaths((newProjectPaths) => {
+      const addedPaths = newProjectPaths.filter((el) => projectPaths.indexOf(el) === -1);
+      const removedPaths = projectPaths.filter((el) => newProjectPaths.indexOf(el) === -1);
+      addedPaths.forEach((path) => this.pathTargets.push(this._defaultPathTarget(path)));
+      this.pathTargets = this.pathTargets.filter((pt) => -1 === removedPaths.indexOf(pt.path));
+      this.refreshTargets(addedPaths);
+      projectPaths = newProjectPaths;
+    });
+
+    atom.commands.add('atom-workspace', 'buildium:refresh-targets', () => this.refreshTargets());
+    atom.commands.add('atom-workspace', 'buildium:select-active-target', () => this.selectActiveTarget());
+  }
+
+  setBusyProvider(busyProvider) {
+    this.busyProvider = busyProvider;
+  }
+
+  _defaultPathTarget(path) {
+    return {
+      path: path,
+      loading: false,
+      targets: [],
+      instancedTools: [],
+      activeTarget: null,
+      tools: [],
+      subscriptions: new CompositeDisposable()
+    };
+  }
+
+  destroy() {
+    this.pathTargets.forEach((pathTarget) =>
+      pathTarget.tools.map((tool) => {
+        tool.removeAllListeners && tool.removeAllListeners('refresh');
+        tool.destructor && tool.destructor();
+      })
+    );
+  }
+
+  setTools(tools) {
+    this.tools = tools || [];
+  }
+
+  refreshTargets(refreshPaths) {
+    DevConsole.log('Refreshing targets');
+
+    refreshPaths = refreshPaths || atom.project.getPaths();
+
+    this.busyProvider && this.busyProvider.add(`Refreshing targets for ${refreshPaths.join(',')}`);
+    const pathPromises = refreshPaths.map((path) => {
+      const pathTarget = this.pathTargets.find((pt) => pt.path === path);
+      pathTarget.loading = true;
+
+      pathTarget.instancedTools = pathTarget.instancedTools.map((t) => t.removeAllListeners && t.removeAllListeners('refresh')).filter(() => false); // Just empty the array
+
+      const settingsPromise = this.tools
+        .map((Tool) => new Tool(path))
+        .filter((tool) => tool.isEligible())
+        .map((tool) => {
+          pathTarget.instancedTools.push(tool);
+          tool.on && tool.on('refresh', this.refreshTargets.bind(this, [path]));
+          return Promise.resolve()
+            .then(async () => await tool.settings())
+            .catch((err) => {
+              if (err instanceof SyntaxError) {
+                atom.notifications.addError('Invalid build file.', {
+                  detail: 'You have a syntax error in your build file: ' + err.message,
+                  dismissable: true
+                });
+              } else {
+                const toolName = tool.getNiceName();
+                atom.notifications.addError('Ooops. Something went wrong' + (toolName ? ' in the ' + toolName + ' build provider' : '') + '.', {
+                  detail: err.message,
+                  stack: err.stack,
+                  dismissable: true
+                });
+              }
+            });
+        });
+
+      return Promise.all(settingsPromise)
+        .then((settings) => {
+          settings = Utils.uniquifySettings(
+            [].concat
+              .apply([], settings)
+              .filter(Boolean)
+              .map((setting) => Utils.getDefaultSettings(path, setting))
+          );
+
+          if (null === pathTarget.activeTarget || !settings.find((s) => s.name === pathTarget.activeTarget)) {
+            /* Active target has been removed or not set. Set it to the highest prio target */
+            pathTarget.activeTarget = settings[0] ? settings[0].name : undefined;
+          }
+
+          // CompositeDisposable cannot be reused, so we must create a new instance on every refresh
+          pathTarget.subscriptions.dispose();
+          pathTarget.subscriptions = new CompositeDisposable();
+
+          settings.forEach((setting, index) => {
+            if (setting.keymap && !setting.atomCommandName) {
+              setting.atomCommandName = `buildium:trigger:${setting.name}`;
+            }
+
+            if (setting.atomCommandName) {
+              pathTarget.subscriptions.add(
+                atom.commands.add('atom-workspace', setting.atomCommandName, (atomCommandName) => this.emit('trigger', atomCommandName))
+              );
+            }
+
+            if (setting.keymap) {
+              const keymapSpec = { 'atom-workspace, atom-text-editor': {} };
+              keymapSpec['atom-workspace, atom-text-editor'][setting.keymap] = setting.atomCommandName;
+              pathTarget.subscriptions.add(atom.keymaps.add(setting.name, keymapSpec));
+            }
+          });
+
+          pathTarget.targets = settings;
+          pathTarget.loading = false;
+
+          return pathTarget;
+        })
+        .catch((err) => {
+          atom.notifications.addError('Ooops. Something went wrong.', {
+            detail: err.message,
+            stack: err.stack,
+            dismissable: true
+          });
+        });
+    });
+
+    return Promise.all(pathPromises)
+      .then((pathTargets) => {
+        this.fillTargets(Utils.activePath(), false);
+        this.emit('refresh-complete');
+        this.busyProvider && this.busyProvider.remove(`Refreshing targets for ${refreshPaths.join(',')}`);
+
+        if (pathTargets.length === 0) {
+          return;
+        }
+
+        if (Config.get('notificationOnRefresh')) {
+          const rows = refreshPaths.map((path) => {
+            const pathTarget = this.pathTargets.find((pt) => pt.path === path);
+            if (!pathTarget) {
+              return `Targets ${path} no longer exists. Is build deactivated?`;
+            }
+            return `${pathTarget.targets.length} targets at: ${path}`;
+          });
+          atom.notifications.addInfo('Build targets parsed.', {
+            detail: rows.join('\n')
+          });
+        }
+      })
+      .catch((err) => {
+        atom.notifications.addError('Ooops. Something went wrong.', {
+          detail: err.message,
+          stack: err.stack,
+          dismissable: true
+        });
+      });
+  }
+
+  fillTargets(path, refreshOnEmpty = true) {
+    if (!this.targetsView) {
+      return;
+    }
+
+    const activeTarget = this.getActiveTarget(path);
+    activeTarget && this.targetsView.setActiveTarget(activeTarget.name);
+
+    this.getTargets(path, refreshOnEmpty)
+      .then((targets) => targets.map((t) => t.name))
+      .then((targetNames) => this.targetsView && this.targetsView.setItems(targetNames));
+  }
+
+  selectActiveTarget() {
+    if (Config.get('refreshOnShowTargetList')) {
+      this.refreshTargets();
+    }
+
+    const path = Utils.activePath();
+    if (!path) {
+      atom.notifications.addWarning('Unable to build.', {
+        detail: 'Open file is not part of any open project in Atom'
+      });
+      return;
+    }
+
+    this.targetsView = new TargetsView();
+
+    if (this.isLoading(path)) {
+      this.targetsView.setLoading('Loading project build targets\u2026');
+    } else {
+      this.fillTargets(path);
+    }
+
+    this.targetsView
+      .awaitSelection()
+      .then((newTarget) => {
+        this.setActiveTarget(path, newTarget);
+
+        this.targetsView = null;
+      })
+      .catch((err) => {
+        this.targetsView.setError(err.message);
+        this.targetsView = null;
+      });
+  }
+
+  getTargets(path, refreshOnEmpty = true) {
+    const pathTarget = this.pathTargets.find((pt) => pt.path === path);
+    if (!pathTarget) {
+      return Promise.resolve([]);
+    }
+
+    if (refreshOnEmpty && pathTarget.targets.length === 0) {
+      return this.refreshTargets([pathTarget.path]).then(() => pathTarget.targets);
+    }
+    return Promise.resolve(pathTarget.targets);
+  }
+
+  getActiveTarget(path) {
+    const pathTarget = this.pathTargets.find((pt) => pt.path === path);
+    if (!pathTarget) {
+      return null;
+    }
+    return pathTarget.targets.find((target) => target.name === pathTarget.activeTarget);
+  }
+
+  setActiveTarget(path, targetName) {
+    this.pathTargets.find((pt) => pt.path === path).activeTarget = targetName;
+    this.emit('new-active-target', path, this.getActiveTarget(path));
+  }
+
+  isLoading(path) {
+    return this.pathTargets.find((pt) => pt.path === path).loading;
+  }
+}
+
+export default TargetManager;
@@ -1,9 +1,6 @@
-'use babel';
-
 import { SelectListView } from 'atom-space-pen-views';
 
 export default class TargetsView extends SelectListView {
-
   constructor() {
     super(...arguments);
     this.show();
@@ -42,13 +39,13 @@ export default class TargetsView extends SelectListView {
   viewForItem(targetName) {
     const activeTarget = this.activeTarget;
     return TargetsView.render(function () {
-      const activeClass = (targetName === activeTarget ? 'active' : '');
+      const activeClass = targetName === activeTarget ? 'active' : '';
       this.li({ class: activeClass + ' build-target' }, targetName);
     });
   }
 
   getEmptyMessage(itemCount) {
-    return (0 === itemCount) ? 'No targets found.' : 'No matches';
+    return 0 === itemCount ? 'No targets found.' : 'No matches';
   }
 
   awaitSelection() {

@@ -1,23 +1,22 @@
-'use babel';
-
 import fs from 'fs';
+import { name, version } from '../package.json';
 import path from 'path';
 
-const uniquifySettings = (settings) => {
+function uniquifySettings(settings) {
   const genName = (name, index) => `${name} - ${index}`;
   const newSettings = [];
-  settings.forEach(setting => {
+  settings.forEach((setting) => {
     let i = 0;
     let testName = setting.name;
-    while (newSettings.find(ns => ns.name === testName)) { // eslint-disable-line no-loop-func
+    while (newSettings.find((ns) => ns.name === testName)) {
       testName = genName(setting.name, ++i);
     }
     newSettings.push({ ...setting, name: testName });
   });
   return newSettings;
-};
+}
 
-const activePath = () => {
+function activePath() {
   const textEditor = atom.workspace.getActiveTextEditor();
   if (!textEditor || !textEditor.getPath()) {
     /* default to building the first one if no editor is active */
@@ -29,28 +28,31 @@ const activePath = () => {
   }
 
   /* otherwise, build the one in the root of the active editor */
-  return atom.project.getPaths().sort((a, b) => (b.length - a.length)).find(p => {
-    try {
-      const realpath = fs.realpathSync(p);
-      return fs.realpathSync(textEditor.getPath()).substr(0, realpath.length) === realpath;
-    } catch (err) {
-      /* Path no longer available. Possible network volume has gone down */
-      return false;
-    }
-  });
-};
+  return atom.project
+    .getPaths()
+    .sort((a, b) => b.length - a.length)
+    .find(async (p) => {
+      try {
+        const realpath = await fs.promises.realpath(p);
+        return (await fs.promises.realpath(textEditor.getPath()).substr(0, realpath.length)) === realpath;
+      } catch (err) {
+        /* Path no longer available. Possible network volume has gone down */
+        return false;
+      }
+    });
+}
 
-const getDefaultSettings = (cwd, setting) => {
+function getDefaultSettings(cwd, setting) {
   return Object.assign({}, setting, {
     env: setting.env || {},
     args: setting.args || [],
     cwd: setting.cwd || cwd,
-    sh: (undefined === setting.sh) ? true : setting.sh,
+    sh: undefined === setting.sh ? true : setting.sh,
     errorMatch: setting.errorMatch || ''
   });
-};
+}
 
-const replace = (value = '', targetEnv) => {
+function replace(value = '', targetEnv) {
   if (!(typeof value === 'string')) {
     return value;
   }
@@ -62,18 +64,20 @@ const replace = (value = '', targetEnv) => {
 
   const editor = atom.workspace.getActiveTextEditor();
 
-  const projectPaths = atom.project.getPaths().map(projectPath => {
+  const projectPaths = atom.project.getPaths().map(async (projectPath) => {
     try {
-      return fs.realpathSync(projectPath);
-    } catch (e) { /* Do nothing. */ }
+      return await fs.promises.realpath(projectPath);
+    } catch (e) {
+      /* Do nothing. */
+    }
     return null;
   });
 
   let projectPath = projectPaths[0];
-  if (editor && (undefined !== editor.getPath())) {
+  if (editor && undefined !== editor.getPath()) {
     const activeFile = fs.realpathSync(editor.getPath());
     const activeFilePath = path.dirname(activeFile);
-    projectPath = projectPaths.find(p => activeFilePath && activeFilePath.startsWith(p));
+    projectPath = projectPaths.find((p) => activeFilePath && activeFilePath.startsWith(p));
     value = value.replace(/{FILE_ACTIVE}/g, activeFile);
     value = value.replace(/{FILE_ACTIVE_PATH}/g, activeFilePath);
     value = value.replace(/{FILE_ACTIVE_NAME}/g, path.basename(activeFile));
@@ -89,6 +93,27 @@ const replace = (value = '', targetEnv) => {
   }
 
   return value;
-};
+}
+
+function capitalizedName() {
+  return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+}
+
+function getVersion() {
+  return `v${version}`;
+}
+
+function getBuildFilenames() {
+  return [
+    'package.json',
+    '.atom-build.json',
+    '.atom-build.yaml',
+    '.atom-build.yml',
+    '.atom-build.json5',
+    '.atom-build.js',
+    '.atom-build.cjs',
+    '.atom-build.toml'
+  ];
+}
 
-export { uniquifySettings, activePath, getDefaultSettings, replace };
+export { uniquifySettings, activePath, getDefaultSettings, replace, capitalizedName, getVersion, getBuildFilenames };
@@ -1,30 +1,31 @@
-@import "ui-variables";
-@import "animations";
+@import 'ui-variables';
 
 .build {
-
   min-width: 250px;
   font-family: Menlo, Consolas, 'DejaVu Sans Mono', monospace;
-  font-weight: 600;
   font-size: @font-size;
 
   .resizer {
-    opacity: 0.0;
+    opacity: 0;
     position: absolute;
     border: solid 4px @base-border-color;
   }
 
   .heading {
     -webkit-user-select: none;
-    line-height: 3.0em;
-    padding: 0 3px;
+    font-family: system-ui;
+    font-size: @font-size;
+    line-height: 3em;
+    padding: 0 5px;
+    border-left: 5px solid;
+    border-color: @text-color-subtle;
 
     &.success {
-      animation: flash-background-success linear 1.2s;
+      border-color: @text-color-success;
     }
 
     &.error {
-      animation: flash-background-error linear 1.2s;
+      border-color: @text-color-error;
     }
 
     .heading-text {
@@ -35,19 +36,13 @@
       &::before {
         margin-right: 5px;
         color: @text-color-error;
-        animation: flash linear infinite 1.0s;
       }
     }
 
     .control-container {
       float: right;
       margin-left: @component-padding;
 
-      .btn {
-        color: @text-color-info;
-        margin: 0 1px;
-      }
-
       .title {
         float: left;
 
@@ -67,25 +62,30 @@
   }
 
   .output {
-    &.override-theme {
-      color: #fff;
-      background-color: #000;
-    }
+    color: @text-color;
+    background-color: @input-background-color;
+    padding: @component-padding;
 
     .terminal {
       padding: 0;
       margin: 0;
       height: 100%;
       width: 100%;
       font-weight: normal;
+      font-family: var(--buildium-terminal-font-family, monospace);
+      font-size: var(--buildium-terminal-font-size);
       > div {
         white-space: nowrap;
         font-size: inherit;
       }
+      ::selection {
+        background-color: @background-color-info;
+        color: @text-color-highlight;
+      }
     }
 
     .terminal-test {
-      background-color:none;
+      background-color: none;
       position: absolute;
       float: left;
       visibility: hidden;
@@ -95,13 +95,26 @@
       border: none;
     }
   }
+
+  .xterm {
+    .xterm-viewport {
+      background-color: inherit;
+      width: 100%;
+      height: 100%;
+      position: absolute;
+    }
+
+    .xterm-helpers {
+      display: none;
+    }
+  }
 }
 
 .opaque-hover {
   transition: opacity 0.2s linear;
   opacity: 0.6;
   &:hover {
-    opacity: 1.0;
+    opacity: 1;
   }
 }
 

@@ -1,4 +1,4 @@
-@import "ui-variables";
+@import 'ui-variables';
 
 atom-panel.left .build,
 atom-panel.right .build {

@@ -1,4 +1,4 @@
-@import "ui-variables";
+@import 'ui-variables';
 
 atom-panel.top .build,
 atom-panel.bottom .build {