export default function patch(args: string[], opts: any, logger: Logger): void {
  const newVersion = args[0];
  const incFn = opts.patch ? (v: SemVer) => v.inc('patch') : (v: SemVer) => v;

  if (!newVersion) {
    logger.fatal('Need to pass in a new version.');
    return;
  }

  const { packages } = require('../../../lib/packages');
  const rootPackageJson = path.join(__dirname, '../../../package.json');

  for (const packageName of Object.keys(packages)) {
    if (packageName == 'angular-cli') {
      // Skip the main package.
      continue;
    }

    const pkgJson = require(packages[packageName].packageJson);
    const version = new SemVer(pkgJson['version']);
    const oldVersion = version.toString();

    pkgJson['version'] = incFn(version).toString();
    fs.writeFileSync(packages[packageName].packageJson, JSON.stringify(pkgJson, null, 2) + '\n');

    logger.info(`${packageName}: ${oldVersion} => ${pkgJson['version']}`);
  }

  // Do the main package.
  const angularCliPackageJson = require(rootPackageJson);
  angularCliPackageJson['version'] = newVersion;
  fs.writeFileSync(rootPackageJson, JSON.stringify(angularCliPackageJson, null, 2) + '\n');
}

 return promise.then(() => {
   toolsLogger.info(name);
   try {
     return npmRun.execSync(`tsc -p ${path.relative(process.cwd(), pkg.root)}`);
   } catch (err) {
     toolsLogger.fatal(`Compilation error.\n${err.stdout}`);
   }
 });

    .then(() => {
      logger.info('Tarring all packages...');

      const tarLogger = new Logger('license', logger);
      return Promise.all(Object.keys(packages).map(pkgName => {
        const pkg = packages[pkgName];
        tarLogger.info(`${pkgName} => ${pkg.tar}`);
        return tarFiles(pkg.tar, pkg.dist);
      }));
    })

    .then(() => {
      // Copy LICENSE into all the packages
      logger.info('Copying LICENSE...');

      const licenseLogger = new Logger('license', logger);
      return Promise.all(Object.keys(packages).map(pkgName => {
        const pkg = packages[pkgName];
        licenseLogger.info(`${pkgName}`);
        return copy('LICENSE', path.join(pkg.dist, 'LICENSE'));
      }));
    })

export function build(args: string[], _opts: any, logger: Logger): void {
  const inFile = args[1] as string;
  const outFile = args[2] as string;
  if (!inFile) {
    logger.fatal('Command build-schema needs an input file.');
    return;
  }

  const output = require('./build-schema').buildSchema(inFile, logger);
  if (outFile) {
    fs.writeFileSync(outFile, output, { encoding: 'utf-8' });
  } else {
    logger.info(output);
  }
}

export default function changelog(args: string[], _opts: any, logger: Logger): void {
  if (args.length == 0) {
    logger.fatal('publish changelog <start-tag>');
    return;
  }

  cl(config, null, {from: args[0]})
    .on('error', function (err: Error) {
      logger.error('Failed to generate changelog: ' + err);
    })
    .pipe(changelogStream)
    .on('close', prependDelta);
}

    .then(() => {
      if (!opts.local) {
        return;
      }

      logger.info('Changing dependencies between packages to tar files...');
      logger.warn('=================================================');
      logger.warn('= THIS SHOULD NOT BE USED FOR PUBLISHING TO NPM =');
      logger.warn('=================================================');

      Object.keys(packages).forEach(pkgName => {
        const pkg = packages[pkgName];
        const json = JSON.parse(fs.readFileSync(pkg.packageJson).toString());

        if (!json['dependencies']) {
          json['dependencies'] = {};
        }
        if (!json['devDependencies']) {
          json['devDependencies'] = {};
        }

        for (const packageName of Object.keys(packages)) {
          if (json['dependencies'].hasOwnProperty(packageName)) {
            json['dependencies'][packageName] = packages[packageName].tar;
          } else if (json['devDependencies'].hasOwnProperty(packageName)) {
            json['devDependencies'][packageName] = packages[packageName].tar;
          }
        }

        fs.writeFileSync(pkg.distPackageJson, JSON.stringify(json, null, 2));
      });
    })

    .then((files: string[]) => {
      logger.info(`Found ${files.length} files...`);

      return files
        .map((fileName) => path.relative(packagesRoot, fileName))
        .filter((fileName) => {
          if (/^@angular[\\\/]cli[\\\/]blueprints/.test(fileName)) {
            return true;
          }
          if (/\.d\.ts$/.test(fileName)) {
            // The last thing we want is d.ts files...
            return false;
          }
          if (/\.spec\.ts$/.test(fileName)) {
            // Also spec.ts files...
            return false;
          }
          if (/spec-utils.ts/.test(fileName)) {
            // TODO: get rid of this by splitting spec utils in its own package.
            return false;
          }
          if (/\.ts$/.test(fileName)) {
            // Verify that it was actually built.
            if (!fs.existsSync(path.join(dist, fileName).replace(/ts$/, 'js'))) {
              throw new Error(`Source found but compiled file not found: "${fileName}".`);
            }

            // Skip all source files, since we have their JS files now.
            return false;
          }

          // The only remaining file we want to ignore is tsconfig and spec files.
          return !(/tsconfig\.json$/.test(fileName))
            && !(/\.spec\./.test(fileName))
            && !(/[\/\\]tests[\/\\]/.test(fileName));
        })
        .map((fileName) => {
          const source = path.join(packagesRoot, fileName);
          const dest = path.join(dist, fileName);

          if (fs.statSync(source).isDirectory()) {
            try {
              fs.mkdirSync(dest);
            } catch (err) {
              if (err.code != 'EEXIST') {
                throw err;
              }
            }
          } else {
            return copy(source, dest);
          }
        })
        .reduce((promise, current) => {
          return promise.then(() => current);
        }, Promise.resolve());
    })