imdone-core 1.54.10 → 2.0.1

package/lib/repository.js

@@ -1,1746 +1,1514 @@
-'use strict'
-
-var _isFunction = require('lodash.isfunction'),
-  _isUndefined = require('lodash.isundefined'),
-  _isString = require('lodash.isstring'),
-  _omit = require('lodash.omit'),
-  _reject = require('lodash.reject'),
-  _noop = require('lodash.noop'),
-  _some = require('lodash.some'),
-  _remove = require('lodash.remove'),
-  _groupBy = require('lodash.groupby'),
-  _where = require('lodash.where'),
-  _template = require('lodash.template'),
-  _union = require('lodash.union'),
-  events = require('events'),
-  languages = require('./languages'),
-  util = require('util'),
-  async = require('async'),
-  path = require('path'),
-  ignore = require('ignore'),
-  File = require('./file'),
-  Config = require('./config'),
-  eol = require('eol'),
-  tools = require('./tools'),
-  inMixinsNoop = tools.inMixinsNoop,
-  constants = require('./constants'),
-  log = require('debug')('imdone-core:Repository'),
-  List = require('./list'),
-  monquery = require('monquery'),
-  sift = require('sift'),
-  fastSort = require('fast-sort/dist/sort.js'),
-  JSONfns = require('json-fns'),
-  Task = require('./task'),
-  newCard = require('./card'),
-  { replaceDateLanguage } = require('./adapters/parsers/DateLanguageParser'),
-  { getRawTask, isNumber, LIST_NAME_PATTERN } = require('./adapters/parsers/task/CardContentParser'),
-  XRegExp = require('xregexp'),
-  promisify = require('util').promisify
-
-const appContext = require('./context/ApplicationContext')
-
-var ERRORS = constants.ERRORS,
-  DEFAULT_FILE_PATTERN = constants.DEFAULT_FILE_PATTERN,
-  ASYNC_LIMIT = constants.ASYNC_LIMIT,
-  DEFAULT_SORT = [{ asc: u => u.order }, { asc: u => u.text }]
-
-// Emits task.found, list.found, file.update and file.delete, file.processed, files.saved
+import _isFunction from 'lodash.isfunction'
+import _isUndefined from 'lodash.isundefined'
+import _isString from 'lodash.isstring'
+import _omit from 'lodash.omit'
+import _reject from 'lodash.reject'
+import _noop from 'lodash.noop'
+import _some from 'lodash.some'
+import _remove from 'lodash.remove'
+import _groupBy from 'lodash.groupby'
+import _where from 'lodash.where'
+import _union from 'lodash.union'
+import Emitter from 'events'
+import { languages } from './languages.js'
+import util from 'util'
+import { parallel, eachLimit, eachSeries, series } from 'async'
+import path from 'path'
+import ignore from 'ignore'
+import { File } from './file.js'
+import eol from 'eol'
+import { tools } from './tools.js'
+const { inMixinsNoop } = tools
+import { constants } from './constants.js'
+import debug from 'debug'
+const log = debug('imdone-core:Repository')
+import { List } from './list.js'
+import monquery from 'monquery'
+import sift from 'sift'
+import { sort } from 'fast-sort'
+import JSONfns from 'json-fns'
+import { Task } from './task.js'
+import { newCard } from './card.js'
+import { replaceDateLanguage } from './adapters/parsers/DateLanguageParser.js'
+import { getRawTask, isNumber, LIST_NAME_PATTERN } from './adapters/parsers/task/CardContentParser.js'
+import { interpolate } from './adapters/parsers/content-transformer.js'
+import XRegExp from 'xregexp'
+import { appContext } from './context/ApplicationContext.js'
+import { computeChecksum } from './checksum.js'
+import { getTasksToModify } from './get-tasks-to-modify.js'
+import { logger } from './adapters/logger.js'
+const { ERRORS, ASYNC_LIMIT, DEFAULT_FILE_PATTERN} = constants
+const DEFAULT_SORT = [{ asc: u => isNumber(u.order) ? u.order : Infinity }, { asc: u => u.text }]
+
+function getTasksByList (
+  repo,
+  tasksAry,
+  noSort,
+  populateFiltered
+) {
+  if (!repo) return []
+  var tasks = {}
+  var allTasks = noSort ? tasksAry : sort(tasksAry).by(DEFAULT_SORT)
+  allTasks.forEach(function (task) {
+    if (!tasks[task.list]) tasks[task.list] = []
+    tasks[task.list].push(task)
+  })
+  var lists = repo.getLists()
+  lists.forEach((list) => {
+    if (list.filter && populateFiltered)
+      return Repository.populateFilteredList(list, tasksAry)
+    list.tasks = tasks[list.name] || []
+  })
+  return lists
+}
 
-/**
- * A Repository is a file system directory in which to look for tasks in files.  The Repository manages all the files
- * and lists in it's path.
- *
- * @constructor
- * @param {} path
- * @param {} config
- * @return
- */
-
-function Repository(_path, config) {
-  var self = this
-
-  events.EventEmitter.call(this)
-  // path is the root path of the repository
-  this.config = config
-  this.path = _path
-  this.files = []
-  this.languages = languages
-  this.allMeta = {}
-  this.metaKeys = new Set()
-  this.allTags = new Set()
-  this.allTopics = new Set()
-  this.allContexts = new Set()
+function populateFilteredList (list, tasks) {
+  try {
+    list.tasks = Repository.query(tasks, list.filter).map((task) => {
+      task.filteredListName = list.name
+      return task
+    })
+  } catch (e) {
+    list.tasks = []
+  }
 }
 
-util.inherits(Repository, events.EventEmitter)
+function regexQuery (tasks, queryString) {
+  return tasks
+    .map((task) => {
+      const escapedQueryString = tools.escapeRegExp(queryString.trim());
 
-Repository.prototype.init = function (cb) {
-  cb(null)
-}
+      // Regex to match occurrences not part of a URL and not already surrounded by `==`
+      const regex = new RegExp(
+        `(?<!https?:\\/\\/[^\\s]*?)\\b${escapedQueryString}\\b(?![^\\s]*\\/)(?<!==)(?!==)`,
+        'gi'
+      );
 
-Repository.prototype.refresh = function (cb) {
-  cb = tools.cb(cb)
-  this.config.dirty = true
-  this.loadConfig((err, config) => {
-    if (err) {
-      return cb(err)
-    }
-    this.config = config
-    this.files = []
-    this.allMeta = {}
-    this.metaKeys = new Set()
-    this.allTags = new Set()
-    this.allTopics = new Set()
-    this.allContexts = new Set()
-    this.readFiles((err, files) => {
-      if (err) {
-        this.emit('initialized', { ok: false })
-        return cb(err)
-      }
-      this.emit('initialized', { ok: true, lists: this.getTasksByList() })
-      if (cb) cb(err, files)
-    })
-  })
-}
+      // Regex to detect Markdown links `[title](url)` where `queryString` is in title or URL
+      const markdownLinkRegex = new RegExp(
+        `\\[([^\\]]*${escapedQueryString}[^\\]]*)\\]\\(([^)]+${escapedQueryString}[^)]*)\\)`,
+        'gi'
+      );
 
-/**
- * Description
- * @method destroy
- * @return
- */
-Repository.prototype.destroy = function () {
-  this.destroyed = true
-  this.removeAllListeners()
-}
+      let match = task.content.match(regex) || task.content.match(markdownLinkRegex);
+      task.match = match;
 
-/**
- * Description
- * @method getId
- * @return CallExpression
- */
-Repository.prototype.getId = function () {
-  return this.getPath()
-}
+      if (match && queryString.trim() && task.interpretedContent) {
+        // Replace standalone occurrences
+        task.interpretedContent = task.interpretedContent.replace(
+          regex,
+          '==$&=='
+        );
 
-Repository.prototype.getProject = function () {
-  return this.project
-}
+        // Replace Markdown links where queryString is in title or URL
+        task.interpretedContent = task.interpretedContent.replace(
+          markdownLinkRegex,
+          (match) => `==${match}==`
+        );
 
-Repository.prototype.getDisplayName = function () {
-  return path.basename(this.path)
-}
+        task.updateDescriptionData();
+      }
 
-Repository.prototype.emitFileUpdate = function (file, force) {
-  if (force || this.shouldEmitFileUpdate(file)) this.emit('file.update', file)
-}
+      return task;
+    })
+    .filter(({ match }) => match);
+};
 
-Repository.prototype.shouldEmitFileUpdate = function (file) {
-  if (this.moving) return
-  if (this.lastMovedFiles) {
-    var index = this.lastMovedFiles.indexOf(file)
-    if (index > -1) {
-      this.lastMovedFiles.splice(index, 1)
-    } else {
-      if (file && file.updated) return true
+
+function parseHideListsFromQueryString (queryString) {
+  const hideLists = []
+  const regex = `hide:(\\s*((${LIST_NAME_PATTERN},?\\s?)+))?`
+  queryString = queryString.replaceAll(
+    // hide lists example `hide: list1, list2`
+    new XRegExp(regex, 'g'),
+    (match, allLists, lists) => {
+      lists && lists.split(',').forEach((list) => {
+        hideLists.push(list.trim())
+      })
+      return ''
     }
-  } else {
-    if (file && file.updated) return true
+  ).trim()
+  return {
+    hideLists,
+    queryString,
   }
 }
 
-Repository.prototype.emitConfigUpdate = function (data) {
-  if (this.savingConfig) return
-  process.nextTick(() => {
-    this.emit('config.update', data)
-  })
-}
-
-/**
- * Description
- * @method createListeners
- * @return
- */
-Repository.prototype.createListeners = function () {
-  if (this.taskListener) return
-  var self = this
-  /**
-   * Description
-   * @method taskFoundListener
-   * @param {} task
-   * @return
-   */
-  this.taskListener = function (event, task) {
-    if (!self.listExists(task.list) && self.config.includeList(task.list)) {
-      const list = new List({ name: task.list })
-      self.addList(list)
-      self.emit('list.found', list)
-      self.saveConfig()
+function parseSortFromQueryString (queryString) {
+  const sort = []
+  queryString = queryString.replace(
+    /\s([+-])([A-Za-z.]+)/g,
+    (match, order, attr) => {
+      const direction = order === '+' ? 'asc' : 'desc'
+      const sortString = `{ "${direction}": "function (o) { return o.${attr};}" }`
+      sort.push(JSONfns.parse(sortString))
+      return ''
     }
-    Object.keys(task.allMeta).forEach(key => self.metaKeys.add(key))
-    task.topics.forEach(topic => self.allTopics.add(topic))
-    task.allTags.forEach(tag => self.allTags.add(tag))
-    task.allContext.forEach(context => self.allContexts.add(context))
-    self.allMeta = self.addAllMeta(task.allMeta)
-    self.emit(event, task)
+  )
+  return {
+    sort,
+    queryString,
   }
+}
 
-  this.taskFoundListener = function (task) {
-    self.taskListener('task.found', task)
+function parseSortFromMongoQuery (mongoQuery) {
+  const sort = []
+  for (const [key, value] of Object.entries(mongoQuery.sort)) {
+    if (value > 0) sort.push({ asc: key })
+    else sort.push({ desc: key })
   }
+  return sort
+}
 
-  this.taskModifiedListener = function (task) {
-    self.taskListener('task.modified', task)
+// function sortByQuery (tasks, queryString = '') {
+//   queryString = replaceDateLanguage(queryString)
+//   let { sort } = Repository.parseSortFromQueryString(queryString)
+//   if (!sort || sort.length === 0) sort = DEFAULT_SORT
+//   sort(tasks).by(sort)
+// }
+
+function filterCards (tasks, _queryString = '') {
+  let query
+  _queryString = replaceDateLanguage(_queryString)
+  let { sort: userSort, queryString } = Repository.parseSortFromQueryString(_queryString);
+  const hideListsQuery = Repository.parseHideListsFromQueryString(queryString);
+  queryString = hideListsQuery.queryString;
+  const hideLists = hideListsQuery.hideLists;
+  try {
+    query = monquery(queryString)
+  } catch (e) {
+    log(`Unable to parse ${_queryString} using monquery`)
+  }
+  let result = []
+  if (query) result = tasks.filter(sift.default(query))
+  if (!query || result.length === 0) {
+    result = Repository.regexQuery(tasks, queryString)
+  }
+  if (!userSort || userSort.length === 0) userSort = DEFAULT_SORT
+  const sorted = sort(result).by(userSort)
+  return {
+    result: sorted,
+    query,
+    sort: userSort,
+    hideLists
   }
 }
 
-Repository.prototype.addAllMeta = function (meta) {
-  const allMeta = Object.assign({}, this.allMeta)
-  Object.keys(meta).forEach((key) => {
-    if (!allMeta[key]) {
-      allMeta[key] = meta[key]
-      return
+function query (tasks, queryString) {
+  return Repository.filterCards(tasks, queryString).result
+}
+
+function replaceDatesInQuery (query) {
+  return Repository.filterObjectValues(query, (key, value) => {
+    let date = Date.parse(value)
+    if (date && /(\d{4})-(\d{2})-(\d{2})/.test(value)) {
+      return date
     }
-    allMeta[key] = _union(allMeta[key], meta[key])
+    return value
   })
-  return allMeta
 }
 
-/**
- * Description
- * @method addList
- * @param {} list
- * @return
- */
-Repository.prototype.addList = async function (list, cb) {
-  cb = tools.cb(cb);
-  if (this.listExists(list.name)) return cb();
-
-  try {
-    list = _omit(list, 'tasks');
-    this.config.lists.push(new List(list));
-
-    if (!list.filter && !/[a-z]/.test(list.name)) {
-      const codeList = list.name.replace(/\s+/g, '-').toUpperCase();
-      if (!this.config.code.include_lists.find((name) => name === codeList)) {
-        this.config.code.include_lists.push(codeList);
+function filterObjectValues (o, cb) {
+  if (o && typeof o === 'object') {
+    for (const [key, value] of Object.entries(o)) {
+      if (value && typeof value === 'object') {
+        Repository.filterObjectValues(value, cb)
+      } else {
+        o[key] = cb(key, value)
       }
     }
+  }
+  return o
+}
 
-    await promisify(this.saveConfig).bind(this)();
-    this.emit('list.modified', list);
-    cb();
-  } catch (err) {
-    cb(err);
+// Emits task.found, list.found, file.update and file.delete, file.processed, files.saved
+export class Repository extends Emitter {
+
+  constructor(_path, config) {
+    super()
+    this.config = config
+    this.path = _path
+    this.files = []
+    this.languages = languages
+    this.allMeta = {}
+    this.metaKeys = new Set()
+    this.allTags = new Set()
+    this.allTopics = new Set()
+    this.allContexts = new Set()
   }
-};
 
-Repository.prototype.removeList = function (list, cb) {
-  return new Promise((resolve, reject) => {
-    var fn = (err) => {
-      if (err) return cb && cb(err) || reject(err)
-      this.emit('list.modified', list)
-      resolve()
-    }
-    if (!this.listExists(list)) return fn()
+  static getTasksByList = getTasksByList
 
-    var lists = _reject(this.getLists(), { name: list })
-    if (this.config.code && this.config.code.include_lists) {
-      this.config.code.include_lists = _reject(this.config.code.include_lists, list)
-    }
-    this.setLists(lists)
-    this.saveConfig(fn)
-  })
-}
+  static populateFilteredList = populateFilteredList
+  
+  static regexQuery = regexQuery
 
-/**
- * Description
- * @method getPath
- * @return MemberExpression
- */
-Repository.prototype.getPath = function () {
-  return this.path
-}
+  static parseHideListsFromQueryString = parseHideListsFromQueryString
 
-/**
- * Description
- * @method getConfig
- * @return MemberExpression
- */
-Repository.prototype.getConfig = function () {
-  return this.config
-}
+  static parseSortFromQueryString = parseSortFromQueryString
 
-/**
- * Description
- * @method getLists
- * @return MemberExpression
- */
-Repository.prototype.getLists = function () {
-  const config = this.getConfig()
-  return config ? config.lists.map(obj => ({...obj})) : []
-}
+  static parseSortFromMongoQuery = parseSortFromMongoQuery
 
-Repository.prototype.getVisibleLists = function () {
-  return _reject(this.getLists(), 'hidden')
-}
+  // static sortByQuery = sortByQuery
 
-Repository.prototype.isListVisible = function (name) {
-  return this.getVisibleLists.find((list) => list.name === name)
-}
+  static filterCards = filterCards
 
-/**
- * Description
- * @method setLists
- * @param {} lists
- * @return ThisExpression
- */
-Repository.prototype.setLists = function (lists) {
-  this.config.lists = lists.map((list) => {
-    return new List(list)
-  })
-  return this
-}
+  static query = query
 
-/**
- * Description
- * @method listExists
- * @param {} name
- * @return BinaryExpression
- */
-Repository.prototype.listExists = function (name) {
-  return this.getConfig().listExists(name)
-}
+  static replaceDatesInQuery = replaceDatesInQuery
 
-/**
- * Save the config file (Implemented in mixins)
- *
- * @method saveConfig
- * @param {} cb
- * @return
- */
-Repository.prototype.saveConfig = function (cb) {
-  inMixinsNoop(cb)
-}
+  static filterObjectValues = filterObjectValues
 
-/**
- * Load the config file (Implemented in mixins)
- *
- * @method loadConfig
- * @return MemberExpression
- */
-Repository.prototype.loadConfig = function (cb) {
-  inMixinsNoop(cb)
-}
+  init () {
+    inMixinsNoop()
+  }
 
-Repository.prototype.migrateTasksByConfig = function (
-  oldConfig,
-  newConfig,
-  cb
-) {
-  if (!oldConfig || !newConfig) return cb()
-  const oldMetaSep = oldConfig.getMetaSep()
-  const newMetaSep = newConfig.getMetaSep()
-  if (oldMetaSep === newMetaSep) return cb()
-  async.eachLimit(
-    this.getFiles(),
-    ASYNC_LIMIT,
-    (file, cb) => {
-      const tasks = fastSort(file.tasks).desc(u => u.line)
-      async.eachSeries(
-        tasks,
-        (task, cb) => {
-          if (!Task.isTask(task)) return cb()
-          task.replaceMetaSep(oldMetaSep, newMetaSep)
-          this.modifyTask(task, false, cb)
-        },
-        (err) => {
-          if (err) return cb(err)
-          if (!file.isModified() || file.getContent().trim() === '') return cb()
-          this.writeFile(file, (err, file) => {
-            this.resetFile(file)
-            if (err) return cb(err)
-            cb(null, file)
-          })
-        }
-      )
-    },
-    cb
-  )
-}
+  // READY Refactor to use async/await
+  // #esm-migration #urgent #important
+  // <!--
+  // order:-240
+  // -->
+  async refresh () {
+    this.files = []
+    this.allMeta = {}
+    this.metaKeys = new Set()
+    this.allTags = new Set()
+    this.allTopics = new Set()
+    this.allContexts = new Set()
+    this.config.dirty = true
 
-/**
- * Get the full path from a relative path
- *
- * @method getFullPath
- * @param {} file
- * @return String
- */
-Repository.prototype.getFullPath = function (file) {
-  if (File.isFile(file)) file = file.path
-  if (file.indexOf(this.path) === 0) return file
-  try {
-    var fullPath = path.join(this.path, file)
-    return fullPath
-  } catch (e) {
-    throw new Error(
-      util.format(
-        'Error getting full path for file:%s and repo path:%s',
-        file,
-        this.path
-      )
-    )
+    let files = await this.getFilesInPath(false)
+    try {
+      const config = await this.loadConfig()
+      this.config = config
+      files = await this.readFiles()
+      this.emit('initialized', { ok: true, lists: this.getTasksByList() })
+    } catch (err) {
+      this.emit('initialized', { ok: false })
+      throw err
+    }
+    return files
   }
-}
 
-/**
- * Get the relative path from repository root
- *
- * @method getRelativePath
- * @param {} fullPath
- * @return String
- */
-Repository.prototype.getRelativePath = function (fullPath) {
-  if (path.sep === '\\') {
-    fullPath = fullPath.replace(/\//g, path.sep)
-  }
-  if (!fullPath.startsWith(this.path)) return fullPath
-  try {
-    var relPath = path.relative(this.path, fullPath)
-    return relPath
-  } catch (e) {
-    throw new Error(
-      util.format(
-        'Error getting relative path for file:%s and repo path:%s',
-        fullPath,
-        this.path
-      )
-    )
+  /**
+   * Description
+   * @method destroy
+   * @return
+   */
+  async destroy () {
+    this.destroyed = true
+    this.removeAllListeners()
   }
-}
 
-/**
- * Is this file OK?  Implemented in mixins
- *
- * @method fileOK
- * @param {} file
- * @param {} includeDirs
- * @return stat
- */
-Repository.prototype.fileOK = function (file, includeDirs, cb) {
-  if (_isFunction(includeDirs)) cb = includeDirs
-  cb(null, true)
-}
+  /**
+   * Description
+   * @method getId
+   * @return CallExpression
+   */
+  getId () {
+    return this.getPath()
+  }
 
-Repository.prototype.setIgnores = function (ignores) {
-  // console.info('ignore patterns:', ignores)
-  this.ignorePatterns = ignores
-  this.ignore = ignore().add(ignores)
-}
+  getProject () {
+    return this.project
+  }
 
-/**
- * Should the relative path be included.
- *
- * @method shouldInclude
- * @param {} relPath
- * @return exclude
- */
-Repository.prototype.shouldInclude = function (relPath) {
-  relPath = this.getRelativePath(relPath)
-  let include = true
-  if (this.config.markdownOnly && relPath) {
-    include = File.isMarkdown(relPath)
-  }
-  if (this.ignore) {
-    try {
-      include = include && (relPath === '' || !this.ignore.ignores(relPath))
-    } catch (e) {
-      console.error(
-        `Failed to check ignore status for dir: [${relPath}] in: [${this.path}]. It will be included.`,
-        e
-      )
-    }
+  getDisplayName () {
+    return path.basename(this.path)
   }
 
-  return include
-}
+  emitFileUpdate (file, force) {
+    if (force || this.shouldEmitFileUpdate(file)) this.emit('file.update', file)
+  }
 
-/**
- * Add or replace a file in the files reference array
- *
- * @method addFile
- * @param {} file
- * @return MemberExpression
- */
-Repository.prototype.addFile = function (file, cb) {
-  if (this.destroyed) return cb(new Error('destroyed'))
-  var self = this
-  this.fileOK(file, function (err, ok) {
-    if (err) return cb(err)
-    if (ok) {
-      var index = self.files.findIndex(({ path }) => path === file.path)
+  shouldEmitFileUpdate (file) {
+    if (this.moving) return
+    if (this.lastMovedFiles) {
+      var index = this.lastMovedFiles.indexOf(file)
       if (index > -1) {
-        self.files[index] = file
+        this.lastMovedFiles.splice(index, 1)
       } else {
-        self.files.push(file)
+        if (file && file.updated) return true
       }
+    } else {
+      if (file && file.updated) return true
     }
-    cb(err, self.files)
-  })
-}
-
-/**
- * Remove a file from the files refrence array
- *
- * @method removeFile
- * @param {} file
- * @return MemberExpression
- */
-Repository.prototype.removeFile = function (file) {
-  if (!File.isFile(file)) throw new Error(ERRORS.NOT_A_FILE)
-  _remove(this.files, f => f.path === file.path)
-
-  return this.files
-}
-
-/**
- * Description
- * @method getFile
- * @param {} path
- * @return CallExpression
- */
-Repository.prototype.getFile = function (path) {
-  path = this.getRelativePath(path)
-  return this.files.find((file) => file.path === path)
-}
+  }
 
-Repository.prototype.getTask = function (id) {
-  if (Task.isTask(id)) {
-    let task = id
-    if (!task.meta.id) return
-    return this.getTasks().find((existingTask) => {
-      return existingTask.meta.id && existingTask.meta.id[0] == task.meta.id[0]
+  emitConfigUpdate (data) {
+    if (this.savingConfig) return
+    process.nextTick(() => {
+      this.emit('config.update', data)
     })
-  } else {
-    let task = this.getTasks().find((task) => task.id === id)
-    if (!task) return
-    return this.getFile(task.source.path)
-      .getTasks()
-      .find((task) => task.id === id)
   }
-}
-
-/**
- * Description
- * @method getFileForTask
- * @param {} task
- * @return CallExpression
- */
-Repository.prototype.getFileForTask = function (task) {
-  return this.getFile(task.getSource().path)
-}
-
-/**
- * Descriptione
- * @method getFiles
- * @param {} paths
- * @return CallExpression
- */
-Repository.prototype.getFiles = function (paths) {
-  if (_isUndefined(paths)) return fastSort(this.files).asc(u => u.path)
-  return this.files.filter((file) => {
-    return paths.includes(file.path)
-  })
-}
 
-Repository.prototype.getFilesWithTasks = function () {
-  const files = this.files.filter((file) => file.getTasks().length > 0)
-  return fastSort(files).asc(u => u.path)
-}
+  // READY Refactor createListeners to use async/await
+  // #esm-migration
+  // <!--
+  // order:-120
+  // -->
+  createListeners () {
+    if (this.taskListener) return
+
+    this.taskListener = async (event, task) => {
+      if (!this.listExists(task.list) && this.config.includeList(task.list)) {
+        const list = new List({ name: task.list })
+        await this.addList(list)
+        this.emit('list.found', list)
+        await this.saveConfig()
+      }
+      Object.keys(task.allMeta).forEach(key => this.metaKeys.add(key))
+      task.topics.forEach(topic => this.allTopics.add(topic))
+      task.allTags.forEach(tag => this.allTags.add(tag))
+      task.allContext.forEach(context => this.allContexts.add(context))
+      this.allMeta = this.addAllMeta(task.allMeta)
+      this.emit(event, task)
+    }
 
-Repository.prototype.resetFile = function (file) {
-  file.reset()
-  file.removeListener('task.found', this.taskFoundListener)
-  file.removeListener('task.modified', this.taskModifiedListener)
-}
+    this.taskFoundListener = (task) => {
+      this.taskListener('task.found', task)
+    }
 
-Repository.prototype.extractTasks = function (file, cb) {
-  cb = tools.cb(cb)
-  var self = this
-  var extract = (file) => {
-    file.on('task.found', self.taskFoundListener)
-    file.on('task.modified', self.taskModifiedListener)
-    const fileContent = file.content
-    file.extractAndTransformTasks(self.getConfig())
-    if (!file.isModified() || fileContent === file.content) {
-      this.resetFile(file)
-      return cb(null, file)
+    this.taskModifiedListener = (task) => {
+      this.taskListener('task.modified', task)
     }
-    file.extractTasks(self.getConfig())
-    self.writeFile(file, (err, file) => {
-      this.resetFile(file)
-      if (err) return cb(err)
-      cb(null, file)
-    })
   }
 
-  if (file.content === null) {
-    this.readFileContent(file, function (err, file) {
-      if (err) return cb(err)
-      extract(file)
+  addAllMeta (meta) {
+    const allMeta = Object.assign({}, this.allMeta)
+    Object.keys(meta).forEach((key) => {
+      if (!allMeta[key]) {
+        allMeta[key] = meta[key]
+        return
+      }
+      allMeta[key] = _union(allMeta[key], meta[key])
     })
-  } else extract(file)
-}
-
-/**
- * Implemented in mixins
- * @method writeFile
- * @param {} file
- * @param {} cb
- * @return
- */
-Repository.prototype.writeFile = function (file, cb) {
-  inMixinsNoop(cb)
-}
-
-/**
- * Implemented in mixins
- * @method getFilesInPath
- * @param {} includeDirs
- * @return CallExpression
- */
-
-Repository.prototype.getFilesInPath = function (includeDirs, cb) {
-  inMixinsNoop(cb)
-}
+    return allMeta
+  }
 
-/**
- * Implemented in mixins
- * @method readFileContent
- * @param {} file
- * @param {} cb
- * @return
- */
-Repository.prototype.readFileContent = function (file, cb) {
-  inMixinsNoop(cb)
-}
+  /**
+   * Description
+   * @method addList
+   * @param {} list
+   * @return
+   */
+  async addList (list) {
+    if (this.listExists(list.name)) return;
 
-/**
- * Description
- * @method readFile
- * @param {} file
- * @param {} cb
- * @return
- */
-Repository.prototype.readFile = function (file, cb) {
-  const checksum = this.checksum || function () {}
-  cb = tools.cb(cb)
-  if (!File.isFile(file)) return cb(new Error(ERRORS.NOT_A_FILE))
-  if (file.deleted) return cb(null, file)
-  var self = this
-
-  var currentChecksum = file.checksum
-  const filePath = file.path
-  if (!/\.\.(\/|\\)/.test(filePath)) {
-    this.readFileContent(file, (err, file) => {
-      if (err) return cb(new Error('Unable to read file:' + filePath))
-      // BACKLOG Allow user to assign a module for content transformation
-      // <!--
-      // order:-800
-      // -->
-      file.checksum = checksum(file.getContent())
-      file.updated = currentChecksum !== file.checksum
-      if (file.updated)
-        self.extractTasks(file, (err) => {
-          if (err) return cb(err)
-          self.addFile(file, (err) => {
-            if (err) log('error:', err)
-            log(`File added. repo: ${self.getPath()} file-path: ${file.path}`)
-            if (err) return cb(err)
-            cb(null, file)
-          })
-        })
-      else cb(null, file)
-    })
-  } else return cb(new Error('Unable to read file:' + file))
-}
+    list = _omit(list, 'tasks');
+    this.config.lists.push(new List(list));
 
-/**
- * Description
- * @method readFiles
- * @param {} files
- * @param {} cb
- * @return
- */
-Repository.prototype.readFiles = function (files, cb) {
-  if (arguments.length === 0) {
-    cb = _noop
-    files = undefined
-  } else if (_isFunction(files)) {
-    cb = files
-    files = undefined
-  } else if (files && !Array.isArray(files))
-    return cb(new Error('files must be an array of files or undefined'))
-
-  cb = tools.cb(cb)
-
-  var self = this
-
-  this.allMeta = {}
-  this.metaKeys = new Set()
-  this.allTags = new Set()
-  this.allContexts = new Set()
-
-  var exec = function (files) {
-    var completed = 0
-    if (files.length < 1) return cb(null, [])
-    async.eachLimit(
-      files,
-      ASYNC_LIMIT,
-      function (file, cb) {
-        self.emit('file.reading', { path: file.path })
-        self.readFile(file, function (err, file) {
-          if (err) return cb(err)
-          completed++
-          self.emit('file.read', {
-            path: file.path,
-            completed: completed,
-          })
-          cb()
-        })
-      },
-      function (err) {
-        cb(err, files)
+    if (!list.filter && !/[a-z]/.test(list.name)) {
+      const codeList = list.name.replace(/\s+/g, '-').toUpperCase();
+      if (!this.config.code.include_lists.find((name) => name === codeList)) {
+        this.config.code.include_lists.push(codeList);
       }
-    )
-  }
-
-  if (files === undefined) {
-    if (this.files && this.files.length > 0) {
-      exec(this.files)
-    } else {
-      this.getFilesInPath(false, (err, files) => {
-        if (err) return cb(err)
-        self.files = files
-        const filesToInclude = files.map((file) => file.path)
-        const fileStats = {
-          count: filesToInclude.length,
-          files: filesToInclude,
-        }
-        this.emit('files.found', fileStats)
-        exec(files)
-      })
     }
-  } else exec(files)
-}
-
-/**
- * Implemented in mixins
- * @method deleteFile
- * @param {} path
- * @param {} cb
- * @return
- */
-Repository.prototype.deleteFile = function (path, cb) {
-  inMixinsNoop(cb)
-}
-
-/**
- * Description
- * @method hasDefaultFile
- * @return CallExpression
- */
-Repository.prototype.hasDefaultFile = function () {
-  return _some(this.getFiles(), function (file) {
-    var regex = new RegExp(DEFAULT_FILE_PATTERN, 'i')
-    return regex.test(file.path)
-  })
-}
-
-/**
- * Description
- * @method getDefaultFile
- * @return file
- */
-Repository.prototype.getDefaultFile = function () {
-  var files = fastSort(this.getFiles()).asc(u => u.path)
-  var file = files.reverse().find((file) => {
-    var regex = new RegExp(DEFAULT_FILE_PATTERN, 'i')
-    return regex.test(file.path)
-  })
-  return file
-}
-
-Repository.prototype.getList = function (name) {
-  return this.getLists().find((list) => list.name === name)
-}
 
+    await this.saveConfig()
+    this.emit('list.modified', list);
+  };
 
-Repository.prototype.getListById = function(id, lists = this.getLists()) {
-  return lists.find((list) => list.id === id)
-}
+  // READY Refactor removeList to use async/await
+  // #esm-migration
+  // <!--
+  // order:-220
+  // -->
+  async removeList (list) {
+    if (!this.listExists(list)) return
 
-Repository.prototype.hideList = function (name, cb) {
-  var self = this
-  cb = tools.cb(cb)
-  var fn = function (err) {
-    if (!err) self.emit('list.modified', name)
-    cb(err)
+    var lists = _reject(this.getLists(), { name: list })
+    if (this.config.code && this.config.code.include_lists) {
+      this.config.code.include_lists = _reject(this.config.code.include_lists, list)
+    }
+    this.setLists(lists)
+    await this.saveConfig()
+    this.emit('list.modified', list)
   }
 
-  var list = this.getList(name)
-  if (list) {
-    list.hidden = true
-    this.saveConfig(fn)
-  } else cb()
-}
+  /**
+   * Description
+   * @method getPath
+   * @return MemberExpression
+   */
+  getPath () {
+    return this.path
+  }
 
-Repository.prototype.showList = function (name, cb) {
-  var self = this
-  cb = tools.cb(cb)
-  var fn = function (err) {
-    if (!err) self.emit('list.modified', name)
-    cb(err)
+  /**
+   * Description
+   * @method getConfig
+   * @return MemberExpression
+   */
+  getConfig () {
+    return this.config
   }
 
-  var list = this.getList(name)
-  if (list) {
-    list.hidden = false
-    this.saveConfig(fn)
-  } else cb()
-}
+  /**
+   * Description
+   * @method getLists
+   * @return MemberExpression
+   */
+  getLists () {
+    const config = this.getConfig()
+    return config ? config.lists.map(obj => ({...obj})) : []
+  }
 
-/**
- * Description
- * @method moveList
- * @param {} name
- * @param {} pos
- * @param {} cb
- * @return
- */
-Repository.prototype.moveList = function (name, pos, cb) {
-  var self = this
-  cb = tools.cb(cb)
-  var list = this.getList(name)
-  // Only modify the lists if the list name exists
-  var fn = function (err) {
-    if (!err) self.emit('list.modified', name)
-    cb(err)
-  }
-
-  if (list) {
-    _remove(this.getLists(), { name: name })
-    this.getLists().splice(pos, 0, list)
-    this.saveConfig(fn)
-  } else cb()
-}
+  getVisibleLists () {
+    return _reject(this.getLists(), 'hidden')
+  }
 
-Repository.prototype.toggleListIgnore = async function (name) {
-  return new Promise(async (resolve, reject) => {
-    var self = this
-    var list = this.getList(name)
-    if (!list) return reject(new Error('List not found'))
-    list.ignore = !list.ignore
-    await this.updateList(list.id, list)
-    this.saveConfig((err) => {
-      if (err) reject(err)
-      self.emit('list.modified', name)
-      resolve()
-    })
-  });
-}
+  isListVisible (name) {
+    return this.getVisibleLists.find((list) => list.name === name)
+  }
 
-Repository.prototype.toggleList = async function (name) {
-  return new Promise(async (resolve, reject) => {
-    var self = this
-    var list = this.getList(name)
-    if (!list) return reject(new Error('List not found'))
-    list.hidden = !list.hidden
-    await this.updateList(list.id, list)
-    this.saveConfig((err) => {
-      if (err) reject(err)
-      self.emit('list.modified', name)
-      resolve()
+  /**
+   * Description
+   * @method setLists
+   * @param {} lists
+   * @return ThisExpression
+   */
+  setLists (lists) {
+    this.config.lists = lists.map((list) => {
+      return new List(list)
     })
-  });
-}
-
-Repository.prototype.updateList = function(id, {name, hidden, ignore, filter}) {
-  return new Promise((resolve, reject) => {
-    const lists = this.getLists()
-    const list = this.getListById(id, lists)
-    const oldName = list.name
-    const hasFilter = list.filter
-    list.name = name
-    list.hidden = hidden
-    list.ignore = ignore
-    if (hasFilter !== undefined) list.filter = filter
-    this.setLists(lists)
-
-    if (oldName === name || hasFilter) {
-      this.saveConfig(err => {
-        if (err) return reject(err)
-        resolve()
-      })
-    } else {
-      this.moveTasksBetweenLists(oldName, name, err => {
-        if (err) return reject(err)
-        resolve()
-      })
-    }
-  })
-}
-
-Repository.prototype.moveTasksBetweenLists = function(oldName, newName, cb) {
-  cb = tools.cb(cb)
-  // Modify the tasks
-  const tasksToModify = this.getTasksInList(oldName)
+    return this
+  }
 
-  const cbfn = (err) => {
-    this.moving = false
-    if (err) return cb(err)
-    this.saveConfig((err) => {
-      if (err) return cb(err)
-      cb(null, { oldName, newName })
-    })
+  /**
+   * Description
+   * @method listExists
+   * @param {} name
+   * @return BinaryExpression
+   */
+  listExists (name) {
+    return this.getConfig().listExists(name)
   }
 
-  const tasksByFile = {} // path: [files]
-  tasksToModify.forEach((task) => {
-    const filePath = task.path
-    if (!tasksByFile[filePath]) {
-      tasksByFile[filePath] = { file: this.getFileForTask(task), tasks: [] }
-    }
-    tasksByFile[filePath].tasks.push(task)
-  })
-  const modifyTasks = Object.values(tasksByFile).map(({ file, tasks }) => {
-    return (cb) => {
-      this.readFileContent(file, (err) => {
-        if (err) return cb(err)
-        try {
-          tasks.forEach((task) => {
-            task.list = newName
-            file.modifyTask(task, this.getConfig(), true)
-          })
-        } catch (err) {
-          return cb(err)
-        }
-        cb()
-      })
-    }
-  })
+  /**
+   * Save the config file (Implemented in mixins)
+   *
+   * @method saveConfig
+   * @return
+   */
+  async saveConfig () {
+    inMixinsNoop()
+  }
 
-  // BACKLOG Let's use saveModifiedFiles here id:15 gh:100 +fix
+  /**
+   * Load the config file (Implemented in mixins)
+   *
+   * @method loadConfig
+   * @return MemberExpression
+   */
+  // READY Refactor loadConfig to use async/await
+  // #esm-migration #urgent
   // <!--
-  // order:-810
+  // order:-160
   // -->
+  async loadConfig () {
+    inMixinsNoop()
+  }
 
-  this.moving = true
-  if (modifyTasks.length > 0) {
-    async.parallel(modifyTasks, (err) => {
-      if (err) return cb(err)
-
-      var fns = Object.values(tasksByFile).map(({ file }) => {
-        return (cb) => {
-          this.writeFile(file, cb)
-        }
-      })
-
-      if (fns.length > 0) {
-        async.parallel(fns, cbfn)
-      } else {
-        cbfn()
-      }
-    })
-  } else cbfn()
-}
-
-Repository.prototype.writeAndExtract = function (file, emit, cb) {
-  this.writeFile(file, emit, (err, file) => {
-    if (err) return cb(new Error('Unable to write file:' + file.path))
-    this.extractTasks(file, (err, file) => {
-      if (err) {
-        return cb(new Error('Unable to extract tasks for file:' + file.path))
-      }
-      
-      this.addFile(file, (err) => {
-        if (err) {
-          err.message = `Unable to add file after extracting tasks: #{file.path}\n${err.message}` 
-          return cb(err)
+  async migrateTasksByConfig (oldConfig, newConfig) {
+    return new Promise((resolve, reject) => {
+      if (!oldConfig || !newConfig) return resolve()
+      const oldMetaSep = oldConfig.getMetaSep()
+      const newMetaSep = newConfig.getMetaSep()
+      if (oldMetaSep === newMetaSep) return resolve()
+      eachLimit(
+        this.getFiles(),
+        ASYNC_LIMIT,
+        (file, cb) => {
+          const tasks = sort(file.tasks).desc(u => u.line)
+          eachSeries(
+            tasks,
+            async (task, cb) => {
+              if (!Task.isTask(task)) return cb()
+              try {
+                task.replaceMetaSep(oldMetaSep, newMetaSep)
+                await this.modifyTask(task, false)
+                cb()
+              } catch (err) {
+                cb(err)
+              }
+            },
+            async (err) => {
+              if (err) return cb(err)
+              if (!file.isModified() || file.getContent().trim() === '') return cb()
+              try {
+                const file = await this.writeFile(file)
+                this.resetFile(file)
+                cb(null, file)
+              } catch (err) {
+                cb(err)
+              }
+            }
+          )
+        },
+        (err) => {
+          if (err) return reject(err)
+          resolve()
         }
-        cb(null, file)
-      })
-    })
-  })
-}
-
-Repository.prototype.writeAndAdd = function (file, emit, cb) {
-  this.writeFile(file, emit, (err, file) => {
-    if (err) return cb(new Error('Unable to write file:' + file.path))
-    this.addFile(file, (err) => {
-      if (err) return cb(new Error('Unable to add file:' + file.path))
-      cb(null, file)
+      )
     })
-  })
-}
+  }
 
-Repository.prototype.deleteTask = function (task, cb) {
-  if (!cb) throw new Error('task, callback required')
-  var self = this
-  var file = self.getFileForTask(task)
-  if (!file) return cb(null)
-  const execute = function (file) {
-    file.deleteTask(task, self.getConfig())
-    if (file.getContentForFile().trim() === '' && file.isMarkDownFile()) {
-      if (file.deleted) return
-      console.log('Deleting empty file:', file.path)
-      self.deleteFile(file.path, cb)
-      file.deleted = true
-      return
+  /**
+   * Get the full path from a relative path
+   *
+   * @method getFullPath
+   * @param {} file
+   * @return String
+   */
+  getFullPath (file) {
+    if (File.isFile(file)) file = file.path
+    if (file.indexOf(this.path) === 0) return file
+    try {
+      var fullPath = path.join(this.path, file)
+      return fullPath
+    } catch (e) {
+      throw new Error(
+        util.format(
+          'Error getting full path for file:%s and repo path:%s',
+          file,
+          this.path
+        )
+      )
     }
-    self.writeAndExtract(file, true, cb)
-  }
-  if (!file.getContent()) {
-    self.readFileContent(file, function (err, file) {
-      if (err) return cb(err)
-      execute(file)
-    })
-  } else {
-    execute(file)
   }
-}
-Repository.prototype.deleteTasks = function (tasks, cb) {
-  if (!cb) throw new Error('tasks, callback required')
-  var self = this
-
-  let files = _groupBy(tasks, (task) => task.source.path) // {path:tasks, path2:tasks}
-  for (let [path, tasks] of Object.entries(files)) {
-    files[path] = fastSort(tasks).desc(u => u.line)
-  }
-  async.eachSeries(
-    Object.entries(files),
-    ([path, tasks], cb) => {
-      const file = this.getFile(path)
-      async.eachSeries(
-        tasks,
-        (task, cb) => {
-          task = newCard(task, this.project, true)
-          this.deleteTask(task, (err) => {
-            cb(err || null, task)
-          })
-        },
-        (err) => {
-          cb(err)
-        }
+
+  /**
+   * Get the relative path from repository root
+   *
+   * @method getRelativePath
+   * @param {} fullPath
+   * @return String
+   */
+  getRelativePath (fullPath) {
+    if (path.sep === '\\') {
+      fullPath = fullPath.replace(/\//g, path.sep)
+    }
+    if (!fullPath.startsWith(this.path)) return fullPath
+    try {
+      var relPath = path.relative(this.path, fullPath)
+      return relPath
+    } catch (e) {
+      throw new Error(
+        util.format(
+          'Error getting relative path for file:%s and repo path:%s',
+          fullPath,
+          this.path
+        )
       )
-    },
-    (err) => {
-      cb(err)
     }
-  )
-}
+  }
 
-Repository.prototype.modifyTaskFromHtml = function (task, html, cb) {
-  cb = tools.cb(cb)
-  var file = this.getFileForTask(task)
-  if (!file.getContent()) {
-    this.readFileContent(file, (err, file) => {
-      if (err) return cb(err)
-      file.modifyTaskFromHtml(task, html)
-      this.writeAndExtract(file, true, cb)
-    })
-  } else {
-    file.modifyTaskFromHtml(task, html)
-    this.writeAndExtract(file, true, cb)
+  /**
+   * Is this file OK?  Implemented in mixins
+   *
+   * @method fileOK
+   * @param {} file
+   * @param {} includeDirs
+   * @return stat
+   */
+  // READY Refactor fileOK to use async/await
+  // #esm-migration #urgent
+  async fileOK (file, includeDirs) {
+    inMixinsNoop()
   }
-}
 
-Repository.prototype.modifyTaskFromContent = function (task, content, cb) {
-  cb = tools.cb(cb)
-  var file = this.getFileForTask(task)
-  if (!file.getContent()) {
-    this.readFileContent(file, (err, file) => {
-      if (err) return cb(err)
-      file.modifyTaskFromContent(task, content, this.getConfig())
-      this.writeAndExtract(file, true, cb)
-    })
-  } else {
-    file.modifyTaskFromContent(task, content, this.getConfig())
-    this.writeAndExtract(file, true, cb)
+  setIgnores (ignores) {
+    // logger.info('ignore patterns:', ignores)
+    this.ignorePatterns = ignores
+    this.ignore = ignore().add(ignores)
   }
-}
 
-Repository.prototype.getTaskContent = function({
-  description,
-  order,
-  text,
-  taskPrefix,
-  taskSyntax,
-}) {
-  const task = newCard(
-    {
-      description,
-      meta: {},
-      order,
-      text,
-      beforeText: taskPrefix,
-      type: taskSyntax,
-    },
-    this.project
-  )
-  Task.prototype.updateOrderMeta.apply(task, [this.config])
-  return task.description.join(eol.lf)
-}
+  /**
+   * Should the relative path be included.
+   *
+   * @method shouldInclude
+   * @param {} relPath
+   * @return exclude
+   */
+  shouldInclude (relPath) {
+    relPath = this.getRelativePath(relPath)
+    let include = true
+    if (this.config.markdownOnly && relPath) {
+      include = File.isMarkdown(relPath)
+    }
+    if (this.ignore) {
+      try {
+        include = include && (relPath === '' || !this.ignore.ignores(relPath))
+      } catch (e) {
+        logger.error(
+          `Failed to check ignore status for dir: [${relPath}] in: [${this.path}]. It will be included.`,
+          e
+        )
+      }
+    }
 
-Repository.prototype.appendTask = function({file, content, list}, cb) {
-  const config = this.getConfig()
-  const interpretedTaskPrefix = _template(config.getTaskPrefix())({
-    date: new Date(),
-  }).trimEnd()
-  const lines = eol.split(content)
-  const text = lines[0]
-  const taskSyntax = config.getNewCardSyntax()
-  const taskPrefix = interpretedTaskPrefix ? `${interpretedTaskPrefix} ` : ''
-  let fileContent = file.getContent()
-  const journalTemplate = this.getConfig().journalTemplate
-  fileContent = fileContent.trim()
-    ? fileContent
-    : journalTemplate
-      && journalTemplate.trim()
-      ? journalTemplate + String(eol.lf)
-      : '';
-
-  const length = fileContent.length
-  const fileIsEmpty = length < 1
-  const crlf = String(eol.crlf)
-  let sep = fileContent.indexOf(crlf) > -1 ? crlf : String(eol.lf)
-  if (fileContent.endsWith(sep) || fileIsEmpty) sep = ''
-  const order = appContext().projectContext.getOrder(list)
-  const description = lines.length > 1 ? Task.padDescription(lines.slice(1), taskPrefix) : []
-  const { orderMeta, tokenPrefix } = config
-  const rawTask = getRawTask({tokenPrefix, orderMeta, list, order, text, type: taskSyntax})      
-  const taskContent = config.orderMeta
-  ? this.getTaskContent({
-      description,
-      order,
-      text,
-      taskPrefix,
-      taskSyntax,
-    })
-  : description.join(eol.lf)
+    return include
+  }
 
-  let appendContent = File.trimBlankLines(
-    `${taskPrefix}${rawTask}${eol.lf}${taskContent}`
-  )
-  
-  fileContent = `${fileContent}${sep}`
-  const cardTerminator = "\n".repeat(2)
-  file.setContent(`${fileContent}${appendContent}${cardTerminator}`)
+  /**
+   * Add or replace a file in the files reference array
+   *
+   * @method addFile
+   * @param {} file
+   * @return MemberExpression
+   */
+  // READY Refactor addFile to use async/await
+  // #esm-migration #urgent
+  async addFile (file) {
+    if (this.destroyed) throw new Error('destroyed')
+    const ok = await this.fileOK(file)
+    if (!ok) return this.files
+    let index = this.files.findIndex(({ path }) => path === file.path)
+    if (index > -1) {
+      this.files[index] = file
+    } else {
+      this.files.push(file)
+    }
 
-  this.writeAndExtract(file, true, (err, file) => {
-    if (err) return cb(err)
-    const task = file.getTasks().find(task => task.text === text && task.list === list)
-    cb(null, file, task)
-  })
-}
+    return this.files
+  }
 
-Repository.prototype.addTaskToFile = function (filePath, list, content, cb) {
-  cb = tools.cb(cb)
-  const relPath = this.getRelativePath(filePath)
-  let file = this.getFile(relPath)
+  /**
+   * Remove a file from the files reference array
+   *
+   * @method removeFile
+   * @param {} file
+   * @return MemberExpression
+   */
+  removeFile (file) {
+    if (!File.isFile(file)) throw new Error(ERRORS.NOT_A_FILE)
+    _remove(this.files, f => f.path === file.path)
 
-  if (file) {
-    this.readFileContent(file, (err, file) => {
-      if (err) return cb(err)
-      this.appendTask({file, content, list}, cb)
-    })
-  } else {
-    const modifiedTime = new Date()
-    const createdTime = new Date()
-    file = new File({
-      repoId: this.path,
-      filePath: relPath,
-      content: '',
-      modifiedTime,
-      createdTime,
-      project: this.project,
-    })
-    this.appendTask({file, content, list}, cb)
+    return this.files
   }
-}
 
-/**
- * Description
- * @method modifyTask
- * @param {} task
- * @return CallExpression
- */
-Repository.prototype.modifyTask = function (task, writeFile, cb) {
-  if (!Task.isTask(task)) return cb()
-  if (_isFunction(writeFile)) {
-    cb = writeFile
-    writeFile = false
-  }
-  cb = tools.cb(cb)
-  const config = this.getConfig()
-  log(
-    'Modifying Task... text:%s list:%s order:%d path:%s id:%s line:%d',
-    task.text,
-    task.list,
-    task.order,
-    task.source.path,
-    task.id,
-    task.line
-  )
-  var self = this
-  let beforeModifyContent
-  var file = this.getFileForTask(task)
-  try {
-    beforeModifyContent = file.getContent()
-  } catch (e) {
-    console.error(
-      `Can't get file for task: {text:'${task.text}', path:'${task.source.path}', line:${task.line}}`
-    )
+  /**
+   * Description
+   * @method getFile
+   * @param {} path
+   * @return CallExpression
+   */
+  getFile (path) {
+    path = this.getRelativePath(path)
+    return this.files.find((file) => file.path === path)
   }
 
-  const modifyTransformExtract = (cb) => {
-    file.modifyTask(task, config, true)
-    file.extractTasks(config)
-    file.transformTask({config, modify:true, task})
-    file.extractTasks(config)
-
-    if (!writeFile || beforeModifyContent === file.getContent()) return cb(null, task)
+  getTask (id) {
+    if (Task.isTask(id)) {
+      let task = id
+      if (!task.meta.id) return
+      return this.getTasks().find((existingTask) => {
+        return existingTask.meta.id && existingTask.meta.id[0] == task.meta.id[0]
+      })
+    } else {
+      let task = this.getTasks().find((task) => task.id === id)
+      if (!task) return
+      return this.getFile(task.source.path)
+        .getTasks()
+        .find((task) => task.id === id)
+    }
+  }
 
-    this.writeAndAdd(file, cb)
+  /**
+   * Description
+   * @method getFileForTask
+   * @param {} task
+   * @return CallExpression
+   */
+  getFileForTask (task) {
+    return this.getFile(task.getSource().path)
   }
 
-  if (!beforeModifyContent) {
-    this.readFileContent(file, (err) => {
-      if (err) return cb(err)
-      modifyTransformExtract(cb)
+  /**
+   * Descriptione
+   * @method getFiles
+   * @param {} paths
+   * @return CallExpression
+   */
+  getFiles (paths) {
+    if (_isUndefined(paths)) return sort(this.files).asc(u => u.path)
+    return this.files.filter((file) => {
+      return paths.includes(file.path)
     })
-  } else {
-    modifyTransformExtract(cb)
   }
-}
 
-Repository.prototype.setTaskPriority = function (_task, index, cb) {
-  if (_task.order === '') return cb()
-  _task.order = index * 10
-  cb()
-}
+  getFilesWithTasks () {
+    const files = this.files.filter((file) => file.getTasks().length > 0)
+    return sort(files).asc(u => u.path)
+  }
 
-function getPreviousIndexWithDifferentOrder(tasks, pos) {
-  let closestIndexWithOrder = -1
+  resetFile (file) {
+    file.reset()
+    file.removeListener('task.found', this.taskFoundListener)
+    file.removeListener('task.modified', this.taskModifiedListener)
+  }
 
-  if (pos === 0) return closestIndexWithOrder
-  
-  let lastTask = tasks[pos] || tasks [pos - 1]
-
-  for (
-    let index = pos - 1;
-    index >= 0 && closestIndexWithOrder < 0;
-    index--
-  ) {
-    const t = tasks[index]
-    if (!tasksHaveSameOrder(lastTask, t)) closestIndexWithOrder = index
-    lastTask = t
-  }
-  return closestIndexWithOrder
-}
+  // READY refactor extractTasks to use async/await
+  // #esm-migration #urgent #important
+  // <!--
+  // order:-100
+  // -->
+  async extractTasks (file) {
+    if (file.content === null) {
+      await this.readFileContent(file)
+    }
+    file.on('task.found', this.taskFoundListener)
+    file.on('task.modified', this.taskModifiedListener)
+    const fileContent = file.content
+    file.extractAndTransformTasks(this.getConfig())
+    if (!file.isModified() || fileContent === file.content) {
+      this.resetFile(file)
+      return file
+    }
+    file.extractTasks(this.getConfig())
+    if (file.modified) await this.writeFile(file)
+    this.resetFile(file)
+    return file
+  }
 
-Repository.getPreviousIndexWithDifferentOrder = getPreviousIndexWithDifferentOrder
+  /**
+   * Implemented in mixins
+   * @method writeFile
+   * @param {} file
+   * @param {} cb
+   * @return
+   */
+  async writeFile (file) {
+    inMixinsNoop()
+  }
 
-function getNextIndexWithDifferentOrder(tasks, pos) {
-  let closestIndexWithOrder = -1
+  /**
+   * Implemented in mixins
+   * @method getFilesInPath
+   * @param {} includeDirs
+   * @return CallExpression
+   */
 
-  let lastTask = tasks[pos]
+  async getFilesInPath (includeDirs) {
+    inMixinsNoop()
+  }
 
-  for (
-    let index = pos;
-    index < tasks.length && closestIndexWithOrder < 0;
-    index++
-  ) {
-    const t = tasks[index]
-    if (!tasksHaveSameOrder(lastTask, t)) closestIndexWithOrder = index
-    lastTask = t
+  /**
+   * Implemented in mixins
+   * @method readFileContent
+   * @param {} file
+   * @return
+   */
+  async readFileContent (file) {
+    inMixinsNoop()
   }
-  return closestIndexWithOrder
-}
 
-Repository.getNextIndexWithDifferentOrder = getNextIndexWithDifferentOrder
+  // READY Refactor readFile to use async/await
+  // #esm-migration #important #urgent
+  // <!--
+  // order:-30
+  // -->
+  async readFile(file) {
+    if (!File.isFile(file)) throw new Error(ERRORS.NOT_A_FILE)
+    if (file.deleted) return file
 
-function taskBeforeAndAfterHaveDifferentOrder(taskList, newPos) {
-  const taskBefore = taskList[newPos - 1]
-  const taskAfter = taskList[newPos]
-  return taskBeforeHasOrder(taskList, newPos)
-    && taskAfterHasOrder(taskList, newPos)
-    && parseFloat(taskBefore.order) !== parseFloat(taskAfter.order)
-}
+    var currentChecksum = file.checksum
+    const filePath = file.path
+    if (/\.\.(\/|\\)/.test(filePath)) throw new Error('Unable to read file:' + file)
 
-function taskBeforeHasOrder(taskList, newPos) {
-  const taskBefore = taskList[newPos - 1]
-  return taskBefore && isNumber(taskBefore.order)
-}
+    await this.readFileContent(file)
+    file.checksum = computeChecksum(file.getContent())
+    file.updated = currentChecksum !== file.checksum
+    if (!file.updated) return file
 
-function taskAfterHasOrder(taskList, newPos) {
-  const taskAfter = taskList[newPos]
-  return taskAfter && isNumber(taskAfter.order)
-}
-function lastTaskHasOrder(taskList) {
-  const lastTask = taskList[taskList.length - 1]
-  return lastTask && isNumber(lastTask.order)
-}
+    await this.extractTasks(file)
+    await this.addFile()
 
-function getTasksToModify(task, taskList, newPos) {
-
-  const previousIndexWithDifferentOrder = getPreviousIndexWithDifferentOrder(taskList, newPos)
-  const nextIndexWithDifferentOrder = getNextIndexWithDifferentOrder(taskList, newPos)
-  const previousTaskWithOrder = taskList[previousIndexWithDifferentOrder]
-  const nextTaskWithOrder = taskList[nextIndexWithDifferentOrder]
-
-  const startingOrder = previousTaskWithOrder
-    ? isNumber(previousTaskWithOrder.order) && previousTaskWithOrder.order || 0
-    : 0;
-  const endingOrder = nextTaskWithOrder
-    ? nextTaskWithOrder.order
-    : null;
-
-  const start = previousIndexWithDifferentOrder > -1 ? previousIndexWithDifferentOrder + 1 : 0;
-  const end = nextIndexWithDifferentOrder > -1 ? nextIndexWithDifferentOrder : newPos + 1;
-  const changes = nextIndexWithDifferentOrder - previousIndexWithDifferentOrder + 1
-  const increment = isNumber(endingOrder) ? (endingOrder - startingOrder) / changes : 10
-  const tasksToModify = []
-  let newOrder = startingOrder
-  let order = 0
-  if (taskList.length === 0) {
-    order = 0
-  } else  if (newPos === 0) {
-    order = taskList[0].order - 10
-  } else if (newPos === taskList.length && lastTaskHasOrder(taskList)) {
-    order = taskList[taskList.length - 1].order + 10
-  } else if (taskBeforeAndAfterHaveDifferentOrder(taskList, newPos)) {
-    order = (taskList[newPos].order - taskList[newPos - 1].order) / 2 + taskList[newPos - 1].order
-  } else if (taskBeforeHasOrder(taskList, newPos) && !taskAfterHasOrder(taskList, newPos)) {
-    order = taskList[newPos - 1].order + 10
-  } else {
-    for (let index = start; index < end; index++) {
-      newOrder += increment
-      if (index === newPos) {
-        task.order = newOrder
-        tasksToModify.push(task)
-        newOrder += increment
+    return file
+  }
+
+  /**
+   * Description
+   * @method readFiles
+   * @param {} files
+   * @param {} cb
+   * @return
+   */
+  // READY Refactor readFiles to use async/await
+  // #esm-migration #urgent #important
+  // <!--
+  // order:-10
+  // -->
+  readFiles (files = this.files) {
+    this.allMeta = {}
+    this.metaKeys = new Set()
+    this.allTags = new Set()
+    this.allContexts = new Set()
+
+    return new Promise(async (resolve, reject) => {
+
+      if (files.length < 1) {
+        files = this.files = await this.getFilesInPath(false)
+        const filesToInclude = files.map((file) => file.path)
+        const fileStats = {
+          count: filesToInclude.length,
+          files: filesToInclude,
+        }
+        this.emit('files.found', fileStats)
       }
+      let completed = 0
+
+      if (files.length < 1) return resolve(files)
+      eachLimit(
+        files,
+        ASYNC_LIMIT,
+        async (file) => {
+          this.emit('file.reading', { path: file.path })
+          await this.readFile(file)
+          completed++
+          this.emit('file.read', {path: file.path, completed: completed})
+        },
+        function (err) {
+          if (err) return reject(err)
+          resolve(files)
+        }
+      )
+    })
+  }
 
-      if (!taskList[index]) continue
-      taskList[index].order = newOrder
-      tasksToModify.push(taskList[index])
-    }  
+  /**
+   * Implemented in mixins
+   * @method deleteFile
+   * @param {} path
+   * @param {} cb
+   * @return
+   */
+ async deleteFile (path, cb) {
+    inMixinsNoop(cb)
   }
 
-  if (tasksToModify.length === 0) {
-    task.order = order
-    tasksToModify.push(task)
+  /**
+   * Description
+   * @method hasDefaultFile
+   * @return CallExpression
+   */
+  hasDefaultFile () {
+    return _some(this.getFiles(), function (file) {
+      var regex = new RegExp(DEFAULT_FILE_PATTERN, 'i')
+      return regex.test(file.path)
+    })
   }
 
-  return tasksToModify
-}
+  /**
+   * Description
+   * @method getDefaultFile
+   * @return file
+   */
+  getDefaultFile () {
+    var files = sort(this.getFiles()).asc(u => u.path)
+    var file = files.reverse().find((file) => {
+      var regex = new RegExp(DEFAULT_FILE_PATTERN, 'i')
+      return regex.test(file.path)
+    })
+    return file
+  }
 
-Repository.getTasksToModify = getTasksToModify
+  getList (name) {
+    return this.getLists().find((list) => list.name === name)
+  }
 
-function tasksHaveSameOrder(taskA, taskB) {
-  return taskA && taskB && taskA.order + "" === taskB.order + ""
-}
 
-Repository.prototype.moveTask = function ({ task, newList = task.list, newPos }, cb) {
-  if (!Task.isTask(task)) {
-    task = newCard(task, this.project, true)
+  getListById(id, lists = this.getLists()) {
+    return lists.find((list) => list.id === id)
   }
-  task = this.getTask(task.id)
 
-  var toListTasks = this.getTasksInList(newList)
-  if (toListTasks === undefined)
-    return cb(new Error(ERRORS.LIST_NOT_FOUND, newList))
-
-  var fromListTasks = this.getTasksInList(task.list)
-  if (fromListTasks === undefined)
-    return cb(new Error(ERRORS.LIST_NOT_FOUND, task.list))
+  // READY Refactor hideList to use async/await
+  // #esm-migration
+  // <!--
+  // order:-150
+  // -->
+  async hideList (name) {
+    await this.setListHidden(name)
+  }
 
-  var sameList = newList == task.list
-  if (!sameList) task.oldList = task.list
-  task.list = newList
+  // READY Refactor showList to use async/await
+  // #esm-migration
+  // <!--
+  // order:-230
+  // -->
+  async showList (name) {
+    await this.setListHidden(name, false)
+  }
 
-  // Move the task to the correct position in the list
-  fromListTasks = _reject(fromListTasks, function (_task) {
-    return _task.equals(task)
-  })
-  toListTasks = _reject(toListTasks, function (_task) {
-    return _task.equals(task)
-  })
-  
-  const tasksToModify = getTasksToModify(task, toListTasks, newPos)
-  task.updateOrderMeta(this.config)
-  toListTasks.splice(newPos, 0, task)
-
-  const tasksToModifySorted = fastSort(tasksToModify).by([{ desc: u => u.line }, { asc: u => u.path }])
-  async.eachSeries(
-    tasksToModifySorted,
-    (task, cb) => {
-      this.modifyTask(task, true, cb)
-    },
-    (err) => {
-      if (err)
-        return cb([
-          new Error(
-            'moveTasks: Error while modifying tasks in the current list'
-          ),
-          err,
-        ])
-      cb(null, task)
+  async setListHidden (name, hidden = true) {
+    const list = this.getList(name)
+    if (list) {
+      list.hidden = hidden
+      await this.saveConfig()
+      this.emit('list.modified', name)
     }
-  )
-}
+  }
 
-Repository.prototype.moveTasks = function (tasks, newList, newPos = 0, noEmit, cb) {
-  var log = require('debug')('moveTasks')
-  var self = this
-  if (this.getList(newList).filter)
-    return cb(new Error(`Tasks can\'t be moved to a filtered list ${newList}.`))
-  var listsModified = [newList]
-  if (_isFunction(noEmit)) {
-    cb = noEmit
-    noEmit = false
-  }
-  this.moving = true
-  cb = tools.cb(cb)
-
-  log('Move tasks to list:%s at position:%d : %j', newList, newPos, tasks)
-  log(
-    'newList before mods:',
-    JSON.stringify(self.getTasksInList(newList), null, 3)
-  )
-  fastSort(tasks).by({desc: t => t.line})
-  async.series(
-    tasks.map((task, i) => {
-      return function (cb) {
-        const foundTask  = self.getTasks().find(({source, line}) => task.source.path === source.path && task.line === line)
-        if (foundTask) {
-          if (listsModified.indexOf(foundTask.list) < 0) listsModified.push(foundTask.list)
-          self.moveTask({ task: foundTask, newList, newPos: newPos + i, noEmit: true }, cb)
-        } else {
-          cb()
-        }
-      }
-    }),
-    function (err) {
-      if (err) {
-        console.error('Error occurred while moving tasks:', err)
-      }
-      self.saveModifiedFiles(function (err, results) {
-        if (err)
-          console.error('Error occurred while saving modified files:', err)
-        self.lastMovedFiles = results
-        var tasksByList = listsModified.map((list) => {
-          return {
-            list: list,
-            tasks: self.getTasksInList(list),
-          }
-        })
-        self.moving = false
-        cb(err, tasksByList)
-        if (!err && !noEmit) self.emit('tasks.moved', tasks)
-      })
+  /**
+   * Description
+   * @method moveList
+   * @param {} name
+   * @param {} pos
+   * @param {} cb
+   * @return
+   */
+  // READY Refactor moveList to use async/await
+  // #esm-migration
+  // <!--
+  // order:-190
+  // -->
+  async moveList (name, pos) {
+    var list = this.getList(name)
+    if (list) {
+      _remove(this.getLists(), { name: name })
+      this.getLists().splice(pos, 0, list)
+      await this.saveConfig()
+      this.emit('list.modified', name)
     }
-  )
-}
+  }
 
-Repository.prototype.moveTasksAsync = function (tasks, newList, newPos, noEmit = false) {
-  return new Promise((resolve, reject) => {
-    this.moveTasks(tasks, newList, newPos, noEmit, (err, tasksByList) => {
-      if (err) return reject(err)
-      resolve(tasksByList)
-    })
-  })
-}
+  // READY Refactor toggleListIgnore to use async/await
+  // #esm-migration
+  // <!--
+  // order:-250
+  // -->
+  async toggleListIgnore (name) {
+    var list = this.getList(name)
+    if (!list) return reject(new Error('List not found'))
+    list.ignore = !list.ignore
+    await this.updateList(list.id, list)
+    await this.saveConfig()
+    this.emit('list.modified', name)
+  }
 
-Repository.prototype.getModifiedFiles = function () {
-  var filesToSave = []
-  this.getFiles().forEach((file) => {
-    if (file.isModified()) filesToSave.push(file)
-  })
-  return filesToSave
-}
+  async toggleList (name) {
+    const list = this.getList(name)
+    if (!list) throw new Error('List not found')
+    list.hidden = !list.hidden
+    await this.updateList(list.id, list)
+    await this.saveConfig()
+    this.emit('list.modified', name)
+  }
 
-Repository.prototype.saveModifiedFiles = function (cb) {
-  const checksum = this.checksum || function () {}
-  var self = this
-  var filesToSave = self.getModifiedFiles()
-  var funcs = filesToSave.map((file) => {
-    return function (cb) {
-      file.checksum = checksum(file.getContent())
-      self.writeAndExtract(file, false, cb)
+  // READY Refactor updateList to use async/await
+  // #esm-migration
+  // <!--
+  // order:-90
+  // -->
+  async updateList(id, {name, hidden, ignore, filter}) {
+    const lists = this.getLists()
+    const list = this.getListById(id, lists)
+    const oldName = list.name
+    const hasFilter = list.filter
+    list.name = name
+    list.hidden = hidden
+    list.ignore = ignore
+    if (hasFilter !== undefined) list.filter = filter
+    this.setLists(lists)
+
+    if (oldName === name || hasFilter) {
+      return await this.saveConfig()
     }
-  })
 
-  if (funcs.length < 1) return cb()
-  this.savingFiles = true
-  async.parallel(funcs, (err) => {
-    this.savingFiles = false
-    if (err) return cb(err)
-    self.emit('files.saved', filesToSave)
-    cb()
-  })
-}
+    await this.moveTasksBetweenLists(oldName, name)
+  }
 
-/**
- * Description
- * @method getTasks
- * @return tasks
- */
-Repository.prototype.getTasks = function () {
-  var tasks = [],
-    self = this
-  this.getFiles().forEach((file) => {
-    Array.prototype.push.apply(tasks, file.getTasks())
-  })
+  getTasksByFile(tasks) {
+    const tasksByFile = {} // path: [files]
+    tasks.forEach((task) => {
+      const filePath = task.path
+      if (!tasksByFile[filePath]) {
+        tasksByFile[filePath] = { file: this.getFileForTask(task), tasks: [] }
+      }
+      tasksByFile[filePath].tasks.push(task)
+      tasksByFile[filePath].tasks = sort(tasksByFile[filePath].tasks).desc(u => u.line)
+    })
+    return tasksByFile
+  }
+  // READY Refactor moveTasksBetweenLists to use async/await
+  // <!--
+  // #esm-migration #needs-testing
+  // order:-80
+  // -->
+  // ## Tasks
+  // - [x] Refactor
+  // - [ ] Test
+  async moveTasksBetweenLists(oldName, newName) {
+    return new Promise((resolve, reject) => {
+      const tasksToModify = this.getTasksInList(oldName)
+      const tasksByFile = this.getTasksByFile(tasksToModify) // { <path/to/file>: {file, tasks} }
+
+      const modifyTasksFunctions = Object.values(tasksByFile).map(({ file, tasks }) => {
+        return async () => {
+          await this.readFileContent(file)
+          tasks.forEach((task) => {
+            task.list = newName
+            file.modifyTask(task, this.getConfig(), true)
+            file.modified = true
+          })
+          return file
+        }
+      })
 
-  return tasks
-}
+      if (modifyTasksFunctions.length < 1) return resolve()
+      this.moving = true
+      parallel(modifyTasksFunctions, async (err, files) => {
+        this.moving = false
+        if (err) {
+          files.forEach(file => this.resetFile(file))
+          return reject(err)
+        }
+        try {
+          await this.saveConfig()
+          await this.saveModifiedFiles()
+          resolve(files)  
+        } catch (err) {
+          reject(err)
+        }
+      })
+    })
+  }
 
-Repository.prototype.getTasksByList = function (noSort) {
-  return Repository.getTasksByList(this, this.getTasks(), noSort, true)
-}
+  // READY Migrate writeAndExtract to use async/await
+  // #esm-migration
+  // <!--
+  // order:-80
+  // -->
+  async writeAndExtract (file, emit) {
+    try {
+      await this.writeFile(file, emit)
+    } catch (err) {
+      new Error('Unable to write file:' + file.path, {cause: err})
+    }
 
-Repository.getTasksByList = function (
-  repo,
-  tasksAry,
-  noSort,
-  populateFiltered
-) {
-  if (!repo) return []
-  var tasks = {}
-  var allTasks = noSort ? tasksAry : fastSort(tasksAry).by(DEFAULT_SORT)
-  allTasks.forEach(function (task) {
-    if (!tasks[task.list]) tasks[task.list] = []
-    tasks[task.list].push(task)
-  })
-  var lists = repo.getLists()
-  lists.forEach((list) => {
-    if (list.filter && populateFiltered)
-      return Repository.populateFilteredList(list, tasksAry)
-    list.tasks = tasks[list.name] || []
-  })
-  return lists
-}
+    try {
+      await this.extractTasks(file)
+    } catch (err) {
+      new Error('Unable to extract tasks for file:' + file.path, { cause: err })
+    }
 
-Repository.populateFilteredList = function (list, tasks) {
-  try {
-    list.tasks = Repository.query(tasks, list.filter).map((task) => {
-      task.filteredListName = list.name
-      return task
-    })
-  } catch (e) {
-    list.tasks = []
+    try {
+      await this.addFile(file)
+    } catch (err) {
+      new Error('Unable to add file after extracting tasks: ' + file.path, { cause: err })
+    }
+
+    return file
   }
-}
 
-/**
- * Description
- * @method getTasksInList
- * @param {} name
- * @return ConditionalExpression
- */
-Repository.prototype.getTasksInList = function (name, offset, limit) {
-  if (!_isString(name)) return []
-  var tasks = _where(this.getTasks(), { list: name })
-  if (tasks.length === 0) return []
-  var allTasks = fastSort(tasks).by(DEFAULT_SORT)
-  if (isNumber(offset) && isNumber(limit))
-    return allTasks.slice(offset, offset + limit)
-  return allTasks
-}
+  // READY Refactor writeAndAdd to use async/await
+  // #esm-migration
+  // <!--
+  // order:-70
+  // -->
+  async writeAndAdd (file, emit) {
+    await this.writeFile(file, emit)
+    await this.addFile(file)
+    return file
+  }
 
-Repository.prototype.getTaskIndex = function (task) {
-  const tasks = this.getTasksInList(task.list)
-  let index = 0
-  tasks.forEach((t, i) => {
-    if (t.id === task.id) index = i
-  })
-  return index
-}
+  // READY Refactor deleteTask to use async/await
+  // #esm-migration
+  // <!--
+  // order:-130
+  // -->
+  async deleteTask (task, cb) {
+    let  file = this.getFileForTask(task)
+    if (!file) return
 
-Repository.prototype.serialize = function () {
-  return JSON.stringify(this, null, 3)
-}
+    if (!file.getContent()) {
+      file = await this.readFileContent(file)
+    }
 
-// WARN: deprecated
-Repository.deserialize = function (repo, cb) {
-  cb = tools.cb(cb)
-  repo = JSON.parse(repo)
-  const config = new Config(repo.config)
-  var newRepo = new Repository(repo.path, config)
-  var count = 0
-  repo.files.forEach((file) => {
-    log('file:%j', file)
-    newRepo.addFile(new File({ file, config, languages }), function (err) {
-      if (err) return cb(err)
-      count++
-      log('count:%d, repo.files.length:%d', count, repo.files.length)
-      if (count == repo.files.length) cb(null, newRepo)
+    file.deleteTask(task, this.getConfig())
+    if (file.getContentForFile().trim() === '' && file.isMarkDownFile()) {
+      if (file.deleted) return
+      logger.log('Deleting empty file:', file.path)
+      this.deleteFile(file.path)
+      file.deleted = true
+      return
+    }
+    await this.writeAndExtract(file, true)
+  }
+
+  // READY Refactor deleteTasks to use async/await
+  // #esm-migration
+  // <!--
+  // order:-140
+  // -->
+  async deleteTasks(tasks) {
+    const files = {}
+    tasks.forEach((task) => {
+      if (!files[task.source.path]) {
+        files[task.source.path] = []
+      } 
+      files[task.source.path].push(task)
+      files[task.source.path] = sort(files[task.source.path]).desc(u => u.line)
     })
-  })
-}
 
-Repository.regexQuery = function (tasks, queryString) {
-  return tasks
-    .map((task) => {
-      const escapedQueryString = tools.escapeRegExp(queryString.trim());
+    await Promise.all(
+      Object.keys(files).map(async (path) => {
+        const tasksInFile = files[path]
+        if (!tasksInFile) return
+        for (const task of tasksInFile) {
+          const taskToDelete = newCard(task, this.project, true)
+          await this.deleteTask(taskToDelete)
+        }
+      })
+    )
 
-      // Regex to match occurrences not part of a URL and not already surrounded by `==`
-      const regex = new RegExp(
-        `(?<!https?:\\/\\/[^\\s]*?)\\b${escapedQueryString}\\b(?![^\\s]*\\/)(?<!==)(?!==)`,
-        'gi'
-      );
+    this.emit('tasks.updated', tasks)
+  }
 
-      // Regex to detect Markdown links `[title](url)` where `queryString` is in title or URL
-      const markdownLinkRegex = new RegExp(
-        `\\[([^\\]]*${escapedQueryString}[^\\]]*)\\]\\(([^)]+${escapedQueryString}[^)]*)\\)`,
-        'gi'
-      );
+  // READY Refactor modifyTaskFromHtml to use async/await
+  // #esm-migration
+  // <!--
+  // order:-170
+  // -->
+  async modifyTaskFromHtml (task, html) {
+    var file = this.getFileForTask(task)
+    if (!file.getContent()) {
+      file = await this.readFileContent(file)
+    }
+    file.modifyTaskFromHtml(task, html)
+    return await this.writeAndExtract(file, true)
+  }
 
-      let match = task.content.match(regex) || task.content.match(markdownLinkRegex);
-      task.match = match;
+  // READY Refactor modifyTaskFromContent to use async/await
+  // #esm-migration
+  // <!--
+  // order:-180
+  // -->
+  async modifyTaskFromContent (task, content, cb) {
+    var file = this.getFileForTask(task)
+    if (!file.getContent()) {
+      file = await this.readFileContent(file)
+    }
+    
+    file.modifyTaskFromContent(task, content, this.getConfig())
+    return await this.writeAndExtract(file, true)
+  }
 
-      if (match && queryString.trim() && task.interpretedContent) {
-        // Replace standalone occurrences
-        task.interpretedContent = task.interpretedContent.replace(
-          regex,
-          '==$&=='
-        );
+  getTaskContent({
+    description,
+    order,
+    text,
+    taskPrefix,
+    taskSyntax,
+  }) {
+    const task = newCard(
+      {
+        description,
+        meta: {},
+        order,
+        text,
+        beforeText: taskPrefix,
+        type: taskSyntax,
+      },
+      this.project
+    )
+    task.updateOrderMeta(this.config)
+    return task.description.join(eol.lf)
+  }
 
-        // Replace Markdown links where queryString is in title or URL
-        task.interpretedContent = task.interpretedContent.replace(
-          markdownLinkRegex,
-          (match) => `==${match}==`
-        );
+  // READY Refactor appendTask to use async/await
+  // #esm-migration
+  // <!--
+  // order:-300
+  // -->
+  async appendTask({file, content, list}) {
+    const config = this.getConfig()
+    const interpretedTaskPrefix = interpolate(
+      config.getTaskPrefix(),
+      { date: new Date() }
+    ).content.trimEnd()
+    const lines = eol.split(content)
+    const text = lines[0]
+    const taskSyntax = config.getNewCardSyntax()
+    const taskPrefix = interpretedTaskPrefix ? `${interpretedTaskPrefix} ` : ''
+    let fileContent = file.getContent()
+    const journalTemplate = this.getConfig().journalTemplate
+    fileContent = fileContent.trim()
+      ? fileContent
+      : journalTemplate
+        && journalTemplate.trim()
+        ? journalTemplate + String(eol.lf)
+        : '';
+
+    const length = fileContent.length
+    const fileIsEmpty = length < 1
+    const crlf = String(eol.crlf)
+    let sep = fileContent.indexOf(crlf) > -1 ? crlf : String(eol.lf)
+    if (fileContent.endsWith(sep) || fileIsEmpty) sep = ''
+    const order = appContext().projectContext.getOrder(list)
+    const description = lines.length > 1 ? Task.padDescription(lines.slice(1), taskPrefix) : []
+    const { orderMeta, tokenPrefix } = config
+    const rawTask = getRawTask({tokenPrefix, orderMeta, list, order, text, type: taskSyntax})      
+    const taskContent = config.orderMeta
+    ? this.getTaskContent({
+        description,
+        order,
+        text,
+        taskPrefix,
+        taskSyntax,
+      })
+    : description.join(eol.lf)
 
-        task.updateDescriptionData();
-      }
+    let appendContent = File.trimBlankLines(
+      `${taskPrefix}${rawTask}${eol.lf}${taskContent}`
+    )
+    
+    fileContent = `${fileContent}${sep}`
+    const cardTerminator = "\n".repeat(2)
+    file.setContent(`${fileContent}${appendContent}${cardTerminator}`)
 
-      return task;
-    })
-    .filter(({ match }) => match);
-};
+    await this.writeAndExtract(file)
+    const task = file.getTasks().find(task => task.text === text && task.list === list)
+    return { file, task }
+  }
 
+  // READY Refactor addTaskToFile to use async/await
+  // #esm-migration
+  // <!--
+  // order:-290
+  // -->
+  async addTaskToFile (filePath, list, content) {
+    const relPath = this.getRelativePath(filePath)
+    let file = this.getFile(relPath)
 
-Repository.parseHideListsFromQueryString = function (queryString) {
-  const hideLists = []
-  const regex = `hide:(\\s*((${LIST_NAME_PATTERN},?\\s?)+))?`
-  queryString = queryString.replaceAll(
-    // hide lists example `hide: list1, list2`
-    new XRegExp(regex, 'g'),
-    (match, allLists, lists) => {
-      lists && lists.split(',').forEach((list) => {
-        hideLists.push(list.trim())
+    if (file) {
+      await this.readFileContent(file)
+      return this.appendTask({file, content, list})
+    } else {
+      const modifiedTime = new Date()
+      const createdTime = new Date()
+      file = new File({
+        repoId: this.path,
+        filePath: relPath,
+        content: '',
+        modifiedTime,
+        createdTime,
+        project: this.project,
       })
-      return ''
+      return this.appendTask({file, content, list})
     }
-  ).trim()
-  return {
-    hideLists,
-    queryString,
   }
-}
 
-Repository.parseSortFromQueryString = function (queryString) {
-  const sort = []
-  queryString = queryString.replace(
-    /\s([+-])([A-Za-z.]+)/g,
-    (match, order, attr) => {
-      const direction = order === '+' ? 'asc' : 'desc'
-      const sortString = `{ "${direction}": "function (o) { return o.${attr}; }" }`
-      sort.push(JSONfns.parse(sortString))
-      return ''
+  /**
+   * Description
+   * @method modifyTask
+   * @param {} task
+   * @return CallExpression
+   */
+  // READY Refactor modifyTask to use async/await
+  // #esm-migration #important #urgent
+  // <!--
+  // order:-60
+  // -->
+  async modifyTask (task, writeFile = false) {
+    if (!Task.isTask(task)) return
+    const config = this.getConfig()
+    log(
+      'Modifying Task... text:%s list:%s order:%d path:%s id:%s line:%d',
+      task.text,
+      task.list,
+      task.order,
+      task.source.path,
+      task.id,
+      task.line
+    )
+    let beforeModifyContent
+    const file = this.getFileForTask(task)
+    try {
+      beforeModifyContent = file.getContent()
+    } catch (e) {
+      logger.error(`Can't get file for task: {text:'${task.text}', path:'${task.source.path}', line:${task.line}}`)
+      throw e
     }
-  )
-  return {
-    sort,
-    queryString,
+
+    if (!beforeModifyContent) await this.readFileContent(file)
+    file.modifyTask(task, config, true)
+    file.extractTasks(config)
+    file.transformTask({config, modify:true, task})
+    file.extractTasks(config)
+
+    if (!writeFile || beforeModifyContent === file.getContent()) return task
+
+    return await this.writeAndAdd(file)
   }
-}
 
-Repository.parseSortFromMongoQuery = function (mongoQuery) {
-  const sort = []
-  for (const [key, value] of Object.entries(mongoQuery.sort)) {
-    if (value > 0) sort.push({ asc: key })
-    else sort.push({ desc: key })
+  // READY Refactor moveTask to use async/await
+  // #esm-migration
+  // <!--
+  // order:-200
+  // -->
+  async moveTask ({ task, newList, newPos }) {
+    if (!Task.isTask(task)) {
+      task = newCard(task, this.project, true)
+    }
+    task = this.getTask(task.id)
+
+    var toListTasks = this.getTasksInList(newList)
+    if (toListTasks === undefined)
+      throw new Error(ERRORS.LIST_NOT_FOUND, newList)
+
+    var fromListTasks = this.getTasksInList(task.list)
+    if (fromListTasks === undefined)
+      throw new Error(ERRORS.LIST_NOT_FOUND, task.list)
+
+    var sameList = newList == task.list
+    if (!sameList) task.oldList = task.list
+    task.list = newList
+
+    // Move the task to the correct position in the list
+    fromListTasks = _reject(fromListTasks, function (_task) {
+      return _task.equals(task)
+    })
+    toListTasks = _reject(toListTasks, function (_task) {
+      return _task.equals(task)
+    })
+    
+    const tasksToModify = getTasksToModify(task, toListTasks, newPos)
+    task.updateOrderMeta(this.config)
+    toListTasks.splice(newPos, 0, task)
+
+    const tasksToModifySorted = sort(tasksToModify).by([{ desc: u => u.line }, { asc: u => u.path }])
+    
+    await eachSeries(
+      tasksToModifySorted,
+      async (task) => {
+        await this.modifyTask(task, true)
+      },
+    )
+
+    return task
   }
-  return sort
-}
 
-Repository.sortByQuery = function (tasks, queryString = '') {
-  queryString = replaceDateLanguage(queryString)
-  let { sort } = Repository.parseSortFromQueryString(queryString)
-  if (!sort || sort.length === 0) sort = DEFAULT_SORT
-  fastSort(tasks).by(sort)
-}
+  // READY Refactor moveTasks to use async/await
+  // #esm-migration #important
+  // <!--
+  // order:-350
+  // -->
+  async moveTasks (tasks, newList, newPos = 0, noEmit = false) {
+    const log = require('debug')('moveTasks')
+    if (this.getList(newList).filter)
+      throw new Error(`Tasks can\'t be moved to a filtered list ${newList}.`)
+    
+    const listsModified = [newList]
+    this.moving = true
+
+    log('Move tasks to list:%s at position:%d : %j', newList, newPos, tasks)
+    log(
+      'newList before mods:',
+      JSON.stringify(this.getTasksInList(newList), null, 3)
+    )
+    await series(
+      sort(tasks).by({desc: t => t.line}).map((task, i) => {
+        return async () =>{
+          const foundTask  = this.getTasks().find(({source, line}) => task.source.path === source.path && task.line === line)
+          if (foundTask) {
+            if (listsModified.indexOf(foundTask.list) < 0) listsModified.push(foundTask.list)
+            await this.moveTask({ task: foundTask, newList, newPos: newPos + i, noEmit: true })
+          } 
+        }
+      })
+    )
 
-Repository.filterCards = function (tasks, _queryString = '') {
-  let query
-  _queryString = replaceDateLanguage(_queryString)
-  let { sort, queryString } = Repository.parseSortFromQueryString(_queryString);
-  const hideListsQuery = Repository.parseHideListsFromQueryString(queryString);
-  queryString = hideListsQuery.queryString;
-  const hideLists = hideListsQuery.hideLists;
-  try {
-    query = monquery(queryString)
-  } catch (e) {
-    log(`Unable to parse ${_queryString} using monquery`)
+    const results = await this.saveModifiedFiles()
+
+    this.lastMovedFiles = results
+    this.moving = false
+
+    if (!noEmit) this.emit('tasks.moved', tasks)
+    return listsModified.map((list) => {
+      return {
+        list: list,
+        tasks: this.getTasksInList(list),
+      }
+    })
   }
-  let result = []
-  if (query) result = tasks.filter(sift.default(query))
-  if (!query || result.length === 0) {
-    result = Repository.regexQuery(tasks, queryString)
+
+  getModifiedFiles () {
+    var filesToSave = []
+    this.getFiles().forEach((file) => {
+      if (file.isModified()) filesToSave.push(file)
+    })
+    return filesToSave
   }
-  if (!sort || sort.length === 0) sort = DEFAULT_SORT
-  fastSort(result).by(sort)
-  return {
-    result,
-    query,
-    sort,
-    hideLists
+
+  // READY Refactor saveModifiedFiles to use async/await
+  // #esm-migration #urgent #important
+  // <!--
+  // order:-110
+  // -->
+  async saveModifiedFiles () {
+    var filesToSave = this.getModifiedFiles()
+    var funcs = filesToSave.map((file) => {
+      return async () => {
+        file.checksum = computeChecksum(file.getContent())
+        await this.writeAndExtract(file, false)
+      }
+    })
+
+    if (funcs.length < 1) return
+
+    this.savingFiles = true
+    await Promise.all(funcs)
+    this.savingFiles = false
+    this.emit('files.saved', filesToSave)
   }
-}
 
-Repository.query = function (tasks, queryString) {
-  return Repository.filterCards(tasks, queryString).result
-}
+  /**
+   * Description
+   * @method getTasks
+   * @return tasks
+   */
+  getTasks () {
+    const tasks = []
+    this.getFiles().forEach((file) => {
+      Array.prototype.push.apply(tasks, file.getTasks())
+    })
 
-Repository.replaceDatesInQuery = function (query) {
-  return Repository.filterObjectValues(query, (key, value) => {
-    let date = Date.parse(value)
-    if (date && /(\d{4})-(\d{2})-(\d{2})/.test(value)) {
-      return date
-    }
-    return value
-  })
-}
+    return tasks
+  }
 
-Repository.filterObjectValues = function (o, cb) {
-  if (o && typeof o === 'object') {
-    for (const [key, value] of Object.entries(o)) {
-      if (value && typeof value === 'object') {
-        Repository.filterObjectValues(value, cb)
-      } else {
-        o[key] = cb(key, value)
-      }
-    }
+  getTasksByList (noSort) {
+    return Repository.getTasksByList(this, this.getTasks(), noSort, true)
   }
-  return o
-}
 
-Repository.prototype.query = function (queryString) {
-  const result = Repository.query(this.getTasks(), queryString)
-  return Repository.getTasksByList(this, result, true)
-}
+  /**
+   * Description
+   * @method getTasksInList
+   * @param {} name
+   * @return ConditionalExpression
+   */
+  getTasksInList (name, offset, limit) {
+    if (!_isString(name)) return []
+    var tasks = _where(this.getTasks(), { list: name })
+    if (tasks.length === 0) return []
+    var allTasks = sort(tasks).by(DEFAULT_SORT)
+    if (isNumber(offset) && isNumber(limit))
+      return allTasks.slice(offset, offset + limit)
+    return allTasks
+  }
+
+  getTaskIndex (task) {
+    const tasks = this.getTasksInList(task.list)
+    let index = 0
+    tasks.forEach((t, i) => {
+      if (t.id === task.id) index = i
+    })
+    return index
+  }
 
-module.exports = Repository
+  query (queryString) {
+    const result = Repository.query(this.getTasks(), queryString)
+    return Repository.getTasksByList(this, result, true)
+  }
+}