hunk.code_window:   }
     if (this.works === 'insideProject' && !this.isWithinProject) {
       return Promise.reject(new SilentError(
         'You have to be inside an angular-cli project in order to use ' +
         'the ' + chalk.green(this.name) + ' command.'
       ));
     }
  
hunk.labels: keep keep keep keep replace keep keep keep
hunk.after_edit:       'You have to be inside an Angular CLI project in order to use ' +
  
hunk.file_path: packages/@angular/cli/ember-cli/lib/models/command.js
hunk.type: replace
file: 'use strict';
  
  /**
  @module ember-cli
  */
  var Promise            = require('../ext/promise');
  var path               = require('path');
  var findup             = Promise.denodeify(require('findup'));
  var resolve            = Promise.denodeify(require('resolve'));
  var fs                 = require('fs');
  var existsSync         = require('exists-sync');
  var find               = require('lodash/find');
  var assign             = require('lodash/assign');
  var forOwn             = require('lodash/forOwn');
  var merge              = require('lodash/merge');
  var debug              = require('debug')('ember-cli:project');
  var Command            = require('../models/command');
  var UI                 = require('../ui');
  var nodeModulesPath    = require('node-modules-path');
  var getPackageBaseName = require('../utilities/get-package-base-name');
  
  /**
    The Project model is tied to your package.json. It is instiantiated
    by giving Project.closest the path to your project.
  
    @class Project
    @constructor
    @param {String} root Root directory for the project
    @param {Object} pkg  Contents of package.json
  */
  function Project(root, pkg, ui, cli) {
    debug('init root: %s', root);
    this.root          = root;
    this.pkg           = pkg;
    this.ui            = ui;
    this.cli           = cli;
    this.addonPackages = {};
    this.addons = [];
    this.liveReloadFilterPatterns = [];
    this.setupNodeModulesPath();
    this._watchmanInfo = {
      enabled: false,
      version: null,
      canNestRoots: false
    };
  }
  
  Project.prototype.hasDependencies = function() {
    return !!this.nodeModulesPath;
  };
  /**
    Sets the path to the node_modules directory for this
    project.
  
    @private
    @method setupNodeModulesPath
   */
  Project.prototype.setupNodeModulesPath = function() {
    this.nodeModulesPath = nodeModulesPath(this.root);
    debug('nodeModulesPath: %s', this.nodeModulesPath);
  };
  
  var processCwd = process.cwd();
  // ensure NULL_PROJECT is a singleton
  var NULL_PROJECT;
  
  Project.nullProject = function (ui, cli) {
    if (NULL_PROJECT) { return NULL_PROJECT; }
  
    NULL_PROJECT = new Project(processCwd, {}, ui, cli);
  
    NULL_PROJECT.isEmberCLIProject = function() {
      return false;
    };
  
    NULL_PROJECT.isEmberCLIAddon = function() {
      return false;
    };
  
    NULL_PROJECT.name = function() {
      return path.basename(process.cwd());
    };
  
    NULL_PROJECT.initializeAddons();
  
    return NULL_PROJECT;
  };
  
  /**
    Returns the name from package.json.
  
    @private
    @method name
    @return {String} Package name
   */
  Project.prototype.name = function() {
    return getPackageBaseName(this.pkg.name);
  };
  
  /**
    Returns whether or not this is an Ember CLI project.
    This checks whether ember-cli is listed in devDependencies.
  
    @private
    @method isEmberCLIProject
    @return {Boolean} Whether this is an Ember CLI project
   */
  Project.prototype.isEmberCLIProject = function() {
    return (this.cli ? this.cli.npmPackage : 'ember-cli') in this.dependencies();
  };
  
  /**
    Returns whether or not this is an Ember CLI addon.
  
    @method isEmberCLIAddon
    @return {Boolean} Whether or not this is an Ember CLI Addon.
   */
  Project.prototype.isEmberCLIAddon = function() {
    return !!this.pkg.keywords && this.pkg.keywords.indexOf('ember-addon') > -1;
  };
  
  /**
    Returns the path to the configuration.
  
    @private
    @method configPath
    @return {String} Configuration path
   */
  Project.prototype.configPath = function() {
    var configPath = 'config';
  
    if (this.pkg['ember-addon'] && this.pkg['ember-addon']['configPath']) {
      configPath = this.pkg['ember-addon']['configPath'];
    }
  
    return path.join(configPath, 'environment');
  };
  
  /**
    Loads the configuration for this project and its addons.
  
    @private
    @method config
    @param  {String} env Environment name
    @return {Object}     Merged confiration object
   */
  Project.prototype.config = function(env) {
    var configPath = this.configPath();
  
    if (existsSync(path.join(this.root, configPath + '.js'))) {
      var appConfig = this.require('./' + configPath)(env);
      var addonsConfig = this.getAddonsConfig(env, appConfig);
  
      return merge(addonsConfig, appConfig);
    } else {
      return this.getAddonsConfig(env, {});
    }
  };
  
  /**
    Returns the addons configuration.
  
    @private
    @method getAddonsConfig
    @param  {String} env       Environment name
    @param  {Object} appConfig Application configuration
    @return {Object}           Merged configuration of all addons
   */
  Project.prototype.getAddonsConfig = function(env, appConfig) {
    this.initializeAddons();
  
    var initialConfig = merge({}, appConfig);
  
    return this.addons.reduce(function(config, addon) {
      if (addon.config) {
        merge(config, addon.config(env, config));
      }
  
      return config;
    }, initialConfig);
  };
  
  /**
    Returns whether or not the given file name is present in this project.
  
    @private
    @method has
    @param  {String}  file File name
    @return {Boolean}      Whether or not the file is present
   */
  Project.prototype.has = function(file) {
    return existsSync(path.join(this.root, file)) || existsSync(path.join(this.root, file + '.js'));
  };
  
  /**
    Resolves the absolute path to a file.
  
    @private
    @method resolve
    @param  {String} file File to resolve
    @return {String}      Absolute path to file
   */
  Project.prototype.resolve = function(file) {
    return resolve(file, {
      basedir: this.root
    });
  };
  
  /**
    Resolves the absolute path to a file synchronously
  
    @private
    @method resolveSync
    @param  {String} file File to resolve
    @return {String}      Absolute path to file
   */
  Project.prototype.resolveSync = function(file) {
    return resolve.sync(file, {
      basedir: this.root
    });
  };
  
  /**
    Calls `require` on a given module.
  
    @private
    @method require
    @param  {String} file File path or module name
    @return {Object}      Imported module
   */
  Project.prototype.require = function(file) {
    if (/^\.\//.test(file)) { // Starts with ./
      return require(path.join(this.root, file));
    } else {
      return require(path.join(this.nodeModulesPath, file));
    }
  };
  
  /**
    Returns the dependencies from a package.json
  
    @private
    @method dependencies
    @param  {Object}  pkg            Package object. If false, the current package is used.
    @param  {Boolean} excludeDevDeps Whether or not development dependencies should be excluded, defaults to false.
    @return {Object}                 Dependencies
   */
  Project.prototype.dependencies = function(pkg, excludeDevDeps) {
    pkg = pkg || this.pkg || {};
  
    var devDependencies = pkg['devDependencies'];
    if (excludeDevDeps) {
      devDependencies = {};
    }
  
    return assign({}, devDependencies, pkg['dependencies']);
  };
  
  /**
    Provides the list of paths to consult for addons that may be provided
    internally to this project. Used for middleware addons with built-in support.
  
    @private
    @method supportedInternalAddonPaths
  */
  Project.prototype.supportedInternalAddonPaths = function() {
    if (!this.root) { return []; }
  
    var internalMiddlewarePath = path.join(__dirname, '../tasks/server/middleware');
  
    return [
      path.join(internalMiddlewarePath, 'tests-server'),
      path.join(internalMiddlewarePath, 'history-support'),
      path.join(internalMiddlewarePath, 'serve-files'),
      path.join(internalMiddlewarePath, 'proxy-server')
    ];
  };
  
  /**
    Loads and initializes all addons for this project.
  
    @private
    @method initializeAddons
   */
  Project.prototype.initializeAddons = function() {
    if (this._addonsInitialized) {
      return;
    }
    this._addonsInitialized = true;
  
    debug('initializeAddons for: %s', this.name());
  
    const cliPkg = require(path.resolve(__dirname, '../../../package.json'));
    const Addon = require('../models/addon');
    const Constructor = Addon.lookup({
      name: '@angular/cli',
      path: path.join(__dirname, '../../../'),
      pkg: cliPkg,
    });
  
    const addon = new Constructor(this.addonParent, this);
    this.addons = [addon];
  };
  
  /**
    Returns what commands are made available by addons by inspecting
    `includedCommands` for every addon.
  
    @private
    @method addonCommands
    @return {Object} Addon names and command maps as key-value pairs
   */
  Project.prototype.addonCommands = function() {
    var commands = {};
    this.addons.forEach(function(addon) {
      var includedCommands = (addon.includedCommands && addon.includedCommands()) || {};
      var addonCommands = {};
  
      for (var key in includedCommands) {
        if (typeof includedCommands[key] === 'function') {
          addonCommands[key] = includedCommands[key];
        } else {
          addonCommands[key] = Command.extend(includedCommands[key]);
        }
      }
      if (Object.keys(addonCommands).length) {
        commands[addon.name] = addonCommands;
      }
    });
    return commands;
  };
  
  /**
    Execute a given callback for every addon command.
    Example:
  
    ```
    project.eachAddonCommand(function(addonName, commands) {
      console.log('Addon ' + addonName + ' exported the following commands:' + commands.keys().join(', '));
    });
    ```
  
    @private
    @method eachAddonCommand
    @param  {Function} callback [description]
   */
  Project.prototype.eachAddonCommand = function(callback) {
    if (this.initializeAddons && this.addonCommands) {
      this.initializeAddons();
      var addonCommands = this.addonCommands();
  
      forOwn(addonCommands, function(commands, addonName) {
        return callback(addonName, commands);
      });
    }
  };
  
  /**
    Path to the blueprints for this project.
  
    @private
    @method localBlueprintLookupPath
    @return {String} Path to blueprints
   */
  Project.prototype.localBlueprintLookupPath = function() {
    return path.join(this.root, 'blueprints');
  };
  
  /**
    Returns a list of paths (including addon paths) where blueprints will be looked up.
  
    @private
    @method blueprintLookupPaths
    @return {Array} List of paths
   */
  Project.prototype.blueprintLookupPaths = function() {
    if (this.isEmberCLIProject()) {
      var lookupPaths = [this.localBlueprintLookupPath()];
      var addonLookupPaths = this.addonBlueprintLookupPaths();
  
      return lookupPaths.concat(addonLookupPaths);
    } else {
      return this.addonBlueprintLookupPaths();
    }
  };
  
  /**
    Returns a list of addon paths where blueprints will be looked up.
  
    @private
    @method addonBlueprintLookupPaths
    @return {Array} List of paths
   */
  Project.prototype.addonBlueprintLookupPaths = function() {
    var addonPaths = this.addons.map(function(addon) {
      if (addon.blueprintsPath) {
        return addon.blueprintsPath();
      }
    }, this);
  
    return addonPaths.filter(Boolean).reverse();
  };
  
  /**
    Reloads package.json
  
    @private
    @method reloadPkg
    @return {Object} Package content
   */
  Project.prototype.reloadPkg = function() {
    var pkgPath = path.join(this.root, 'package.json');
  
    // We use readFileSync instead of require to avoid the require cache.
    this.pkg = JSON.parse(fs.readFileSync(pkgPath, { encoding: 'utf-8' }));
  
    return this.pkg;
  };
  
  /**
    Re-initializes addons.
  
    @private
    @method reloadAddons
   */
  Project.prototype.reloadAddons = function() {
    this.reloadPkg();
    this._addonsInitialized = false;
    return this.initializeAddons();
  };
  
  /**
    Find an addon by its name
  
    @private
    @method findAddonByName
    @param  {String} name Addon name as specified in package.json
    @return {Addon}       Addon instance
   */
  Project.prototype.findAddonByName = function(name) {
    this.initializeAddons();
  
    var exactMatch = find(this.addons, function(addon) {
      return name === addon.name || (addon.pkg && name === addon.pkg.name);
    });
  
    if (exactMatch) {
      return exactMatch;
    }
  
    return find(this.addons, function(addon) {
      return name.indexOf(addon.name) > -1 || (addon.pkg && name.indexOf(addon.pkg.name) > -1);
    });
  };
  
  /**
    Generate test file contents.
  
    This method is supposed to be overwritten by test framework addons
    like `ember-cli-qunit` and `ember-cli-mocha`.
  
    @public
    @method generateTestFile
    @param {String} moduleName Name of the test module (e.g. `JSHint`)
    @param {Object[]} tests Array of tests with `name`, `passed` and `errorMessage` properties
    @return {String} The test file content
   */
  Project.prototype.generateTestFile = function(/* moduleName, tests */) {
    var message = 'Please install an Ember.js test framework addon or update your dependencies.';
  
    if (this.ui) {
      this.ui.writeDeprecateLine(message)
    } else {
      console.warn(message);
    }
  
    return '';
  };
  
  /**
    Returns a new project based on the first package.json that is found
    in `pathName`.
  
    @private
    @static
    @method closest
    @param  {String} pathName Path to your project
    @return {Promise}         Promise which resolves to a {Project}
   */
  Project.closest = function(pathName, _ui, _cli) {
    var ui = ensureUI(_ui);
    return closestPackageJSON(pathName)
      .then(function(result) {
        debug('closest %s -> %s', pathName, result);
        if (result.pkg && result.pkg.name === 'ember-cli') {
          return Project.nullProject(_ui, _cli);
        }
  
        return new Project(result.directory, result.pkg, ui, _cli);
      })
      .catch(function(reason) {
        handleFindupError(pathName, reason);
      });
  };
  
  /**
    Returns a new project based on the first package.json that is found
    in `pathName`.
  
    @private
    @static
    @method closestSync
    @param  {String} pathName Path to your project
    @param  {UI} _ui The UI instance to provide to the created Project.
    @return {Project}         Project instance
   */
  Project.closestSync = function(pathName, _ui, _cli) {
    var ui = ensureUI(_ui);
    var directory, pkg;
  
    if (_cli && _cli.testing) {
      directory = existsSync(path.join(pathName, 'package.json')) && process.cwd();
      if (!directory) {
        if (pathName.indexOf(path.sep + 'app') > -1) {
          directory = findupPath(pathName);
        } else {
          pkg = {name: 'ember-cli'};
        }
      }
    } else {
      directory = findupPath(pathName);
    }
    if (!pkg) {
      pkg = JSON.parse(fs.readFileSync(path.join(directory, 'package.json')));
    }
  
    debug('dir' + directory);
    debug('pkg: %s', pkg);
    if (pkg && pkg.name === 'ember-cli') {
      return Project.nullProject(_ui, _cli);
    }
  
    debug('closestSync %s -> %s', pathName, directory);
    return new Project(directory, pkg, ui, _cli);
  };
  
  /**
    Returns a new project based on the first package.json that is found
    in `pathName`, or the nullProject.
  
    The nullProject signifies no-project, but abides by the null object pattern
  
    @private
    @static
    @method projectOrnullProject
    @param  {UI} _ui The UI instance to provide to the created Project.
    @return {Project}         Project instance
   */
  Project.projectOrnullProject = function(_ui, _cli) {
    try {
      return Project.closestSync(process.cwd(), _ui, _cli);
    } catch (reason) {
      if (reason instanceof Project.NotFoundError) {
        return Project.nullProject(_ui, _cli);
      } else {
        throw reason;
      }
    }
  };
  
  /**
    Returns the project root based on the first package.json that is found
  
    @return {String} The project root directory
   */
  Project.getProjectRoot = function () {
    try {
      var directory = findup.sync(process.cwd(), 'package.json');
      var pkg = require(path.join(directory, 'package.json'));
  
      if (pkg && pkg.name === 'ember-cli') {
        debug('getProjectRoot: named \'ember-cli\'. Will use cwd: %s', process.cwd());
        return process.cwd();
      }
  
      debug('getProjectRoot %s -> %s', process.cwd(), directory);
      return directory;
    } catch (reason) {
      if (isFindupError(reason)) {
        debug('getProjectRoot: not found. Will use cwd: %s', process.cwd());
        return process.cwd();
      } else {
        throw reason;
      }
    }
  };
  
  function NotFoundError(message) {
    this.name = 'NotFoundError';
    this.message = message;
    this.stack = (new Error()).stack;
  }
  
  NotFoundError.prototype = Object.create(Error.prototype);
  NotFoundError.prototype.constructor = NotFoundError;
  
  Project.NotFoundError = NotFoundError;
  
  function ensureUI(_ui) {
    var ui = _ui;
  
    if (!ui) {
      // TODO: one UI (lib/cli/index.js also has one for now...)
      ui = new UI({
        inputStream:  process.stdin,
        outputStream: process.stdout,
        ci:           process.env.CI || /^(dumb|emacs)$/.test(process.env.TERM),
        writeLevel:   ~process.argv.indexOf('--silent') ? 'ERROR' : undefined
      });
    }
  
    return ui;
  }
  
  function closestPackageJSON(pathName) {
    return findup(pathName, 'package.json')
      .then(function(directory) {
        return Promise.hash({
          directory: directory,
          pkg: require(path.join(directory, 'package.json'))
        });
      });
  }
  
  function findupPath(pathName) {
    try {
      return findup.sync(pathName, 'package.json');
    } catch (reason) {
      handleFindupError(pathName, reason);
    }
  }
  
  function isFindupError(reason) {
    // Would be nice if findup threw error subclasses
    return reason && /not found/i.test(reason.message);
  }
  
  function handleFindupError(pathName, reason) {
    if (isFindupError(reason)) {
      throw new NotFoundError('No project found at or up from: `' + pathName + '`');
    } else {
      throw reason;
    }
  }
  
  // Export
  module.exports = Project;
  