return new Promise<Operations>((resolve, reject) => {
        fs.exists(tasksJsonPath, exists => {
            if (exists) {
                fs.readFile(tasksJsonPath, (err, buffer) => {
                    if (err) {
                        return reject(err);
                    }

                    const text = buffer.toString();
                    let tasksConfiguration: tasks.TaskConfiguration;

                    try {
                        tasksConfiguration = tolerantParse(text);
                    }
                    catch (error) {
                        vscode.window.showErrorMessage(`Failed to parse tasks.json file`);
                        return resolve({ updateTasksJson: false });
                    }

                    let buildTasks = getBuildTasks(tasksConfiguration);

                    resolve({ updateTasksJson: buildTasks.length === 0 });
                });
            }
            else {
                resolve({ addTasksJson: true });
            }
        });
    });

/**
 * Validates the existence of the specified file
 *
 * @param {string} projectPath Path to project
 * @param {string} checkPath Absolute path to file to check
 */
async function validateExistance(projectPath: string, checkPath: string) {
  const fileExists = await fs.exists(checkPath);

  if (!fileExists) {
    const friendlyPath = checkPath.replace(projectPath, './');
    throw new Error(`The project doesn't contain a ${friendlyPath}`);
  }
}

 return new Promise<any>(resolve => {
     fs.exists(file, yes => {
         if (yes) {
             return fs.unlink(file, () => resolve());
         }
         resolve();
     });
 });

/**
 * Return public/index.html contents
 *
 * @param {string} projectPath
 */
async function getIndexHTML(projectPath: string) {
  const indexHTMLPath = path.join(projectPath, 'public', 'index.html');
  const fileExists = await fs.exists(indexHTMLPath);
  if (!fileExists) {
    return '';
  }

  return fs.readFileSync(indexHTMLPath) || '';
}

/**
 * Return package.json object
 *
 * @param {string} projectPath
 * @returns
 */
async function getPackageJSON(projectPath: string) {
  const packageJSONPath = path.join(projectPath, 'package.json');
  const fileExists = await fs.exists(packageJSONPath);
  if (!fileExists) {
    throw new Error(`The project doesn't have a package.json.`);
  }

  return fs.readJson(packageJSONPath);
}

 return new Promise((resolve, reject) => {
   fs.exists(fileName, (exist) => {
     if (exist) {
       resolve();
     } else {
       reject(new Error(`File ${fileName} was expected to exist but not found...`));
     }
   });
 });

 fs.exists(generator.launchJsonPath, exists => {
     if (exists) {
         resolve(true);
     }
     else {
         fs.exists(generator.tasksJsonPath, exists => {
             resolve(exists);
         });
     }
 });

    return new Promise<void>((resolve, reject) => {
        fs.exists(path, exists => {
            if (exists) {
                // TODO: Should we check after unlinking to see if the file still exists?
                fs.unlink(path, err => {
                    if (err) {
                        return reject(err);
                    }

                    resolve();
                });
            }
        });
    });