files.forEach(str => {
  console.log(
    fs.statSync(str).isDirectory() ? chalk.cyan(str) :
    str[0] === '.' ? chalk.grey(str) :
    chalk.red(str)
  )
})

              setImmediate(() => {
                const prettyQuery = printGraphql(definitelyQueryDocumentAst)
                  .replace(/\s+/g, ' ')
                  .trim();
                const errorCount = (result.errors || []).length;
                const ms = timeDiff[0] * 1e3 + timeDiff[1] * 1e-6;

                let message: string;
                if (resultStatusCode === 401) {
                  // Users requested that JWT errors were raised differently:
                  //
                  //   https://github.com/graphile/postgraphile/issues/560
                  message = chalk.red(`401 authentication error`);
                } else if (resultStatusCode === 403) {
                  message = chalk.red(`403 forbidden error`);
                } else {
                  message = chalk[errorCount === 0 ? 'green' : 'red'](`${errorCount} error(s)`);
                }

                // tslint:disable-next-line no-console
                console.log(
                  `${message} ${
                    pgRole != null ? `as ${chalk.magenta(pgRole)} ` : ''
                  }in ${chalk.grey(`${ms.toFixed(2)}ms`)} :: ${prettyQuery}`,
                );
              });

task(':publish', async () => {
  const tag = argv['tag'];
  const version = buildConfig.projectVersion;
  const currentDir = process.cwd();

  console.log();
  if (!tag) {
    console.log(grey('> You can specify the tag by passing --tag=labelName.\n'));
    console.log(green(`Publishing version "${version}" to the latest tag...`));
  } else {
    console.log(yellow(`Publishing version "${version}" to the ${tag} tag...`));
  }
  console.log();

  if (releasePackages.length > 1) {
    console.warn(yellow('Warning: Multiple packages will be released.'));
    console.warn(yellow('Warning: Packages to be released:', releasePackages.join(', ')));
    console.warn();
  }

  console.log(yellow('> Make sure to check the "requiredAngularVersion" in the package.json.'));
  console.log(yellow('> The version in the config defines the peer dependency of Angular.'));
  console.log();

  // Iterate over every declared release package and publish it on NPM.
  for (const packageName of releasePackages) {
    await _execNpmPublish(tag, packageName);
  }

  process.chdir(currentDir);
});

    public static reportDiagnostic( diagnostic: ts.Diagnostic ) {
        if ( !diagnostic ) {
            return;
        }

        var output = "";

        if ( diagnostic.file ) {
            var loc = ts.getLineAndCharacterOfPosition( diagnostic.file, diagnostic.start );

            output += chalk.gray( `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): ` );
        }

        var category;

        switch ( diagnostic.category ) {
            case ts.DiagnosticCategory.Error:
                category = chalk.red( ts.DiagnosticCategory[diagnostic.category].toLowerCase() );
                break;
            case ts.DiagnosticCategory.Warning:
                category = chalk.yellow( ts.DiagnosticCategory[diagnostic.category].toLowerCase() );
                break;
            default:
                category = chalk.green( ts.DiagnosticCategory[diagnostic.category].toLowerCase() );
        }

        output += `${category} TS${chalk.white( diagnostic.code + '' )}: ${chalk.grey( ts.flattenDiagnosticMessageText( diagnostic.messageText, "\n" ) )}`;

        Logger.log( output );
    }

 group.commits = group.commits.filter((commit: any) => {
   // Note that we cannot compare the SHA's because the commits will have a different SHA
   // if they are being cherry-picked into a different branch.
   if (previousContent.includes(commit.header)) {
     console.log(grey(`Skipping: "${commit.header}" (${commit.hash})`));
     return false;
   }
   return true;
 });

    authenticator({client: {jwt, publicKeyPath, columns: 100}}, (message:string, isSuccess:boolean) => {

      expect(authService.verify).toHaveBeenCalledWith(jwt, '/tmp/path/to/key');

      expect(vantageScope.log)
        .toHaveBeenCalledWith(chalk.grey(`You were authenticated with a JSON Web token verified against the public key at /tmp/path/to/key`));

      expect(isSuccess).toBe(true);
      expect(message).toBe(null);
      cb();
    });

export default async function lint() {
  // typescript
  const typescriptFileFailures = await lintAsync();
  if (typescriptFileFailures.length) {
    // log all failures with some basic formatting
    error('');
    for (const fileFailure of typescriptFileFailures) {
      error(`Found ${yellow(fileFailure.failureCount.toString())} failure(s) in ${yellow(fileFailure.failures[0].getFileName())}:`);
      for (const failure of fileFailure.failures) {
        const fileName = failure.getFileName();
        if (!sourceFileLines[fileName]) {
          // attention: sourceFile is a private property!
          sourceFileLines[fileName] = (failure as any).sourceFile.text.split('\n');
        }
        const lines = sourceFileLines[fileName];

        const { line, character } = failure.getStartPosition().getLineAndCharacter();
        error(`  ${failure.getFailure()} ${grey(`(at [${line + 1}:${character + 1}]: ${lines[line].trim()})`)}`);

      }
      error('');
    }
  }

  // documentation
  const documentationFailures = [];
  if (!project.private) {
    if (!(await existsAsync(join(process.cwd(), 'README.md')))) {
      documentationFailures.push(`You have ${yellow('no README.md')}.`);
    }
    if (!project.keywords || !project.keywords.length) {
      documentationFailures.push(`You have ${yellow('no keywords')} set in your ${yellow('package.json')}.`);
    }
    if (!(await existsAsync(join(process.cwd(), 'examples')))) {
      documentationFailures.push(`You have ${yellow('no examples/')} directory.`);
    } else {
      const contents = (await readdirAsync(join(process.cwd(), 'examples'))).filter(content => content !== '.DS_Store');
      if (!contents.length) {
        documentationFailures.push(`Your ${yellow('examples/')} directory ${yellow('is empty')}.`);
      }
    }
  }
  if (documentationFailures.length) {
    error('');
    error(`You're project ${yellow(`isn't private`)}, but it has ${yellow(documentationFailures.length.toString())} documentation failure(s).`);
    documentationFailures.forEach(msg => error(`  ${msg}`));
    error('');
  }

  if (typescriptFileFailures.length || documentationFailures.length) {
    throw `${cyan('lint')} failed.`;
  }
};

 cols.forEach(colDescription => {
     console.log(chalk.bold(colDescription.name + ': ' + colDescription.count + ' builds'));
     var collection = db.getCollection(colDescription.name);
     var successfulBuilds = collection.find({result: 'SUCCESS'});
     var failedBuilds = collection.find({result: 'FAILURE'});
     var abortedBuilds = collection.find({result: 'ABORTED'});
     var buildingNow = collection.find({building: true});
     
     console.log('\tBuilding now: ' + chalk.bold(buildingNow.length));
     console.log('\tSuccessful builds: ' + chalk.green(successfulBuilds.length));
     console.log('\tFailed builds: ' + chalk.red(failedBuilds.length));
     console.log('\tAborted builds: ' + chalk.grey(abortedBuilds.length));
 });

          .then((payload: any) => {
            remoteCliContext.logger.info(`${payload.username} has been authenticated with token`)
              .debug('Token:', token);
            let displayBanner = `Hi ${payload.username}, Welcome to Ubiquits runtime cli.`;
            if (args.client.columns >= 80) {
              displayBanner = bannerBg(undefined, token);
            }
            this.log(chalk.grey(`You were authenticated with a JSON Web token verified against the public key at ${keyPath}`));
            this.log(displayBanner);
            this.log(` Type 'help' for a list of available commands`);

            return cb(null, true);
          })

 /**
  * Log a database query to the console
  * @param query SQL query to log
  * @param params values to place in SQL query's placeholders
  * @param t number of ms elapsed while query was running
  */
 protected logQuery(query: string, params: JSONArray, t: number) {
   let tv = timeVal(t);
   let timestring =
     t < 5
       ? chalk.bgGreenBright.black(tv)
       : t < 100 ? chalk.bgYellowBright.black(tv) : chalk.bgRedBright.white(tv);
   logger.info(
     [
       colorizeQuery(query) + ` (${timestring})`,
       `${chalk.grey('PARAMS:')} ${JSON.stringify(params)}`
     ].join('\n')
   );
   return t;
 }