@basementuniverse/kanbn 2.0.0 → 2.5.0

package/src/controller/move.js

@@ -1,7 +1,10 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 const inquirer = require('inquirer');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
 inquirer.registerPrompt('selectLine', require('inquirer-select-line'));
 
 /**
@@ -42,24 +45,83 @@ async function interactive(columns, columnName, columnNames, sortedColumnNames,
  * @param {?number} [position=null]
  * @param {boolean} [relative=false]
  */
-function moveTask(taskId, columnName, position = null, relative = false) {
+function moveTask(taskId, columnName, position = null, relative = false, add = false) {
   kanbn
-  .moveTask(taskId, columnName, position, relative)
+  .moveTask(taskId, columnName, position, relative, add)
   .then(taskId => {
     console.log(`Moved task "${taskId}" to column "${columnName}"`);
+    utility.showActionWarnings(kanbn);
   })
   .catch(error => {
     utility.error(error);
   });
 }
 
+/**
+ * Add a task to the board it's being moved on, because it isn't on that board yet
+ * @param {string} taskId
+ * @param {string} columnName
+ * @param {string} boardSlug
+ * @param {boolean} verbose
+ */
+async function addTaskToBoard(taskId, columnName, boardSlug, verbose) {
+  try {
+    await kanbn.addTaskToBoard(taskId, columnName);
+    if (verbose) {
+      console.log(utility.replaceTags(
+        `{d}Task "${taskId}" wasn't on board "${boardSlug}" - it has been added{d}`
+      ));
+    }
+    console.log(`Moved task "${taskId}" to column "${columnName}"`);
+    utility.showActionWarnings(kanbn);
+  } catch (error) {
+    utility.error(error);
+  }
+}
+
+/**
+ * Move a simple task to another column on the board it's on
+ * @param {object} boardKanbn The board-scoped Kanbn instance
+ * @param {string} input
+ * @param {?string} columnName The column to move to, or null to leave it where it is
+ * @param {?number} position
+ */
+async function moveSimpleTask(boardKanbn, input, columnName, position) {
+  try {
+    const moved = await boardKanbn.moveSimpleTask(input, columnName, position);
+    console.log(`Moved simple task "${moved.text}" to column "${moved.toColumn}"`);
+  } catch (error) {
+    utility.error(error);
+  }
+}
+
+/**
+ * Move a simple task onto another board
+ * @param {object} sourceKanbn The board the simple task is on
+ * @param {string} input
+ * @param {string} targetSlug
+ * @param {?string} columnName
+ * @param {?number} position
+ */
+async function moveSimpleTaskToBoard(sourceKanbn, input, targetSlug, columnName, position) {
+  try {
+    const moved = await sourceKanbn.moveSimpleTaskToBoard(input, targetSlug, columnName, position);
+    console.log(
+      `Moved simple task "${moved.text}" to column "${moved.toColumn}" on board "${moved.toBoard}"`
+    );
+  } catch (error) {
+    utility.error(error);
+  }
+}
+
 module.exports = async args => {
 
-  // Make sure kanbn has been initialised
-  if (!await kanbn.initialised()) {
-    utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
     return;
   }
+  kanbn = scoped;
 
   // Get the task that we're moving
   const taskId = args._[1];
@@ -68,14 +130,6 @@ module.exports = async args => {
     return;
   }
 
-  // Make sure the task exists
-  try {
-    await kanbn.taskExists(taskId);
-  } catch (error) {
-    utility.error(error);
-    return;
-  }
-
   // Get the index and make sure it has some columns
   let index;
   try {
@@ -90,6 +144,90 @@ module.exports = async args => {
     return;
   }
 
+  // Re-use sprint option for position
+  let newPosition = args.position || args.p;
+  if (newPosition) {
+    newPosition = parseInt(utility.trimLeftEscapeCharacters(newPosition));
+    if (isNaN(newPosition)) {
+      utility.error('Position value must be numeric');
+      return;
+    }
+  } else {
+    newPosition = null;
+  }
+
+  // A task file always wins, so a simple task - a line in a column that isn't a task link - is only
+  // looked for when nothing has this task id. Falling through leaves every existing error unchanged
+  if (!(await kanbn.taskFileExists(taskId))) {
+    const targetColumn = args.column ? utility.strArg(args.column) : null;
+    const matches = await kanbn.findSimpleTasks(taskId);
+    if (matches.length) {
+      const simpleTask = await utility.resolveSimpleTask(kanbn, taskId, null, matches);
+      if (simpleTask !== null) {
+        await moveSimpleTask(
+          kanbn,
+          taskId,
+          targetColumn === null ? simpleTask.column : targetColumn,
+          newPosition
+        );
+      }
+      return;
+    }
+
+    // A simple task lives in one board file rather than in a shared task file, so `-b` names the
+    // board it is moving to rather than the board it is on
+    if (args.board) {
+      const sourceKanbn = await workspace.boardFromArgs({});
+      if ((await sourceKanbn.findSimpleTasks(taskId)).length) {
+        await moveSimpleTaskToBoard(
+          sourceKanbn,
+          taskId,
+          await kanbn.resolveBoardSlug(),
+          targetColumn,
+          newPosition
+        );
+        return;
+      }
+    }
+  }
+
+  // Moving a task on a board it isn't on yet adds it there, so that pulling work onto a board is one
+  // command rather than two. --no-add turns that back into an error. The main board is unaffected:
+  // moving an untracked task there has always been an error and still is
+  const boardSlug = await kanbn.resolveBoardSlug();
+  const onThisBoard = boardSlug in await workspace.findTaskBoards(taskId);
+  if (!onThisBoard && !(await kanbn.isMainBoard())) {
+    if (!(await kanbn.taskFileExists(taskId))) {
+      utility.error(`No task file found with id "${taskId}"`);
+      return;
+    }
+    if (!args.add) {
+      utility.error(
+        `Task "${taskId}" is not on board "${boardSlug}"\n` +
+        'Drop {b}--no-add{b} to add it to this board while moving it'
+      );
+      return;
+    }
+    let targetColumn = columnNames[0];
+    if (args.column) {
+      targetColumn = utility.strArg(args.column);
+      if (columnNames.indexOf(targetColumn) === -1) {
+        utility.error(`Column "${targetColumn}" doesn't exist`);
+        return;
+      }
+    }
+    await addTaskToBoard(taskId, targetColumn, boardSlug, kanbn.isVerbose(index));
+    return;
+  }
+
+  // Make sure the task exists
+  try {
+    await kanbn.taskExists(taskId);
+  } catch (error) {
+    utility.error(error);
+    return;
+  }
+
   // Get column name if specified
   const currentColumnName = await kanbn.findTaskColumn(taskId);
   let columnName = currentColumnName;
@@ -103,16 +241,6 @@ module.exports = async args => {
 
   // Re-use sprint option for position
   const currentPosition = index.columns[currentColumnName].indexOf(taskId);
-  let newPosition = args.position || args.p;
-  if (newPosition) {
-    newPosition = parseInt(utility.trimLeftEscapeCharacters(newPosition));
-    if (isNaN(newPosition)) {
-      utility.error('Position value must be numeric');
-      return;
-    }
-  } else {
-    newPosition = null;
-  }
 
   // Get a list of sorted columns
   const sortedColumnNames = 'columnSorting' in index.options ? Object.keys(index.options.columnSorting) : [];
@@ -138,6 +266,6 @@ module.exports = async args => {
 
   // Otherwise move task non-interactively
   } else {
-    moveTask(taskId, columnName, newPosition, args.relative);
+    moveTask(taskId, columnName, newPosition, args.relative, args.add);
   }
 };

package/src/controller/remove.js

@@ -1,30 +1,76 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 const inquirer = require('inquirer');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
+/**
+ * Remove a simple task - a line in a column that isn't a task link. There is no file to delete and
+ * nothing to archive: the line is the whole of it
+ * @param {string} input
+ * @param {boolean} force True to skip the confirmation prompt
+ */
+async function removeSimpleTask(input, force) {
+  if (!force) {
+    const answers = await inquirer.prompt([
+      {
+        type: 'confirm',
+        message: 'Are you sure you want to remove this simple task?',
+        name: 'sure',
+        default: false
+      }
+    ]);
+    if (!answers.sure) {
+      return;
+    }
+  }
+  try {
+    const removed = await kanbn.deleteSimpleTask(input);
+    console.log(`Removed simple task "${removed.text}" from column "${removed.column}"`);
+  } catch (error) {
+    utility.error(error);
+  }
+}
+
 /**
  * Remove a task
  * @param {string} taskId
- * @param {boolean} removeFile
+ * @param {boolean} removeFile True if the task file should be deleted as well as the index entry
+ * @param {boolean} allBoards Remove the task from every board that references it
+ * @param {string} boardSlug The board the task is being removed from
+ * @param {boolean} secondaryBoard True if that board isn't the main board
  */
-function removeTask(taskId, removeFile) {
+function removeTask(taskId, removeFile, allBoards, boardSlug, secondaryBoard) {
   kanbn
-  .deleteTask(taskId, removeFile)
+  .deleteTask(taskId, removeFile, allBoards)
   .then(taskId => {
-    console.log(`Removed task "${taskId}"${removeFile ? ' from the index' : ' file and index entry'}`);
+    console.log(
+      `Removed task "${taskId}"${removeFile ? ' file and index entry' : ' from the index'}` +
+      (secondaryBoard && !allBoards ? ` on board "${boardSlug}"` : '')
+    );
+    utility.showActionWarnings(kanbn);
   })
   .catch(error => {
-    utility.error(error);
+
+    // Only a task that's on other boards can be removed from all of them, or from this one alone
+    utility.error(utility.replaceTags(
+      /other board/.test(error.message)
+        ? `${error.message}\nUse {b}--all-boards{b} to remove it from all of them, or {b}--index{b} ` +
+          'to remove it from this board only'
+        : error.message
+    ));
   });
 }
 
 module.exports = async args => {
 
-  // Make sure kanbn has been initialised
-  if (!await kanbn.initialised()) {
-    utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
     return;
   }
+  kanbn = scoped;
 
   // Get the task that we're removing
   const taskId = args._[1];
@@ -33,11 +79,19 @@ module.exports = async args => {
     return;
   }
 
-  // Make sure the task exists
+  // Make sure the task exists. A task file always wins, so a simple task is only looked for when
+  // nothing has this task id
   try {
     await kanbn.taskExists(taskId);
   } catch (error) {
-    utility.error(error);
+    if (await kanbn.taskFileExists(taskId)) {
+      utility.error(error);
+      return;
+    }
+    const simpleTask = await utility.resolveSimpleTask(kanbn, taskId, error);
+    if (simpleTask !== null) {
+      await removeSimpleTask(taskId, !!args.force);
+    }
     return;
   }
 
@@ -50,9 +104,15 @@ module.exports = async args => {
     return;
   }
 
+  // A task file is shared between boards, so deleting it while another board still references it
+  // needs --all-boards. Removing the task from this board's index alone is always safe
+  const allBoards = !!args['all-boards'];
+  const boardSlug = await kanbn.resolveBoardSlug();
+  const secondaryBoard = !(await kanbn.isMainBoard());
+
   // If the force flag is specified, remove the task without asking
   if (args.force) {
-    removeTask(taskId, args.index);
+    removeTask(taskId, !args.index, allBoards, boardSlug, secondaryBoard);
 
   // Otherwise, prompt for confirmation first
   } else {
@@ -65,7 +125,7 @@ module.exports = async args => {
       }
     ]).then(async answers => {
       if (answers.sure) {
-        removeTask(taskId, args.index);
+        removeTask(taskId, !args.index, allBoards, boardSlug, secondaryBoard);
       }
     }).catch(error => {
       utility.error(error);

package/src/controller/rename.js

@@ -1,7 +1,10 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 const inquirer = require('inquirer');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
 /**
  * Rename a task interactively
  * @param {object} taskData
@@ -51,11 +54,12 @@ function renameTask(taskId, newTaskName, currentTaskName) {
 
 module.exports = async args => {
 
-  // Make sure kanbn has been initialised
-  if (!await kanbn.initialised()) {
-    utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
     return;
   }
+  kanbn = scoped;
 
   // Get the task that we're renaming
   const taskId = args._[1];

package/src/controller/restore.js

@@ -1,16 +1,30 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
 /**
  * Restore a task from the archive
  * @param {string} taskId
  * @param {string|null} columnName
  */
-function restoreTask(taskId, columnName) {
+function restoreTask(taskId, columnName, singleBoard) {
   kanbn
-  .restoreTask(taskId, columnName)
+  .restoreTask(taskId, columnName, singleBoard)
   .then(taskId => {
     console.log(`Restored task "${taskId}" from the archive`);
+    utility.showActionWarnings(kanbn);
+
+    // A task is restored to every board it was on when it was archived. A board that has since been
+    // deleted is skipped rather than failing the restore, but the user should hear about it
+    const missing = kanbn.lastRestoreWarnings || [];
+    if (missing.length) {
+      console.log(
+        `Couldn't restore "${taskId}" to ${missing.length === 1 ? 'board' : 'boards'} ` +
+        `${missing.map(slug => `"${slug}"`).join(', ')} - no longer ${missing.length === 1 ? 'exists' : 'exist'}`
+      );
+    }
   })
   .catch(error => {
     utility.error(error);
@@ -19,11 +33,12 @@ function restoreTask(taskId, columnName) {
 
 module.exports = async args => {
 
-  // Make sure kanbn has been initialised
-  if (!await kanbn.initialised()) {
-    utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
     return;
   }
+  kanbn = scoped;
 
   // Get the task that we're archiving
   const taskId = args._[1];
@@ -56,6 +71,7 @@ module.exports = async args => {
     }
   }
 
-  // Archive task
-  restoreTask(taskId, columnName);
+  // Restore the task. Without --board it goes back to every board it was on when it was archived;
+  // with --board it goes only to that one
+  restoreTask(taskId, columnName, !!args.board);
 };

package/src/controller/sort.js

@@ -1,7 +1,10 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 const inquirer = require('inquirer');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
 inquirer.registerPrompt('recursive', require('inquirer-recursive'));
 
 const sorterFields = [
@@ -178,6 +181,46 @@ const sorterFields = [
       '--assigned'
     ],
     filterable: true
+  },
+  {
+    name: 'Overdue',
+    field: 'overdue',
+    options: [
+      '--overdue'
+    ],
+    filterable: false
+  },
+  {
+    name: 'Is started',
+    field: 'isStarted',
+    options: [
+      '--is-started'
+    ],
+    filterable: false
+  },
+  {
+    name: 'Is completed',
+    field: 'isCompleted',
+    options: [
+      '--is-completed'
+    ],
+    filterable: false
+  },
+  {
+    name: 'In started column',
+    field: 'inStartedColumn',
+    options: [
+      '--in-started-column'
+    ],
+    filterable: false
+  },
+  {
+    name: 'In completed column',
+    field: 'inCompletedColumn',
+    options: [
+      '--in-completed-column'
+    ],
+    filterable: false
   }
 ];
 
@@ -275,6 +318,13 @@ function sortColumn(columnName, sorters, save) {
 
 module.exports = async (args, argv) => {
 
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
+    return;
+  }
+  kanbn = scoped;
+
   // Sortable fields and aliases
   const sortOptions = Object.fromEntries(utility.zip(
     sorterFields.map(sorterField => sorterField.options).flat(),
@@ -296,8 +346,14 @@ module.exports = async (args, argv) => {
     '--save'
   ];
 
-  // Get the column that we're sorting
-  argv = argv.slice(3);
+  // Get the column that we're sorting. --board is consumed above, so drop it and its value before
+  // the sorter walk below, which would otherwise read the board slug as a sorter filter
+  argv = argv.slice(3).filter((arg, i, all) => {
+    if (arg === '--board' || arg === '-b') {
+      return false;
+    }
+    return !(i > 0 && (all[i - 1] === '--board' || all[i - 1] === '-b'));
+  });
   const columnName = args._.length > 1 ? args._[1] : null;
 
   // Column name must be defined if not sorting interactively

package/src/controller/sprint.js

@@ -1,7 +1,10 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 const inquirer = require('inquirer');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
 /**
  * Start a new sprint interactively
  * @param {?string} [name=null] The sprint name
@@ -43,11 +46,21 @@ async function interactive(name = null, description = null) {
  * @param {string} name
  * @param {string} description
  */
-function startSprint(name, description) {
+function startSprint(name, description, verbose, secondaryBoard) {
   kanbn
   .sprint(name, description, new Date())
   .then(sprint => {
     console.log(`Started new sprint "${sprint.name}" at ${sprint.start.toISOString()}`);
+
+    // Sprints are workspace-level unless a board declares its own list, so say where this one went
+    // rather than leaving the user to guess which file changed
+    if (verbose && secondaryBoard) {
+      console.log(utility.replaceTags(
+        sprint.board === null
+          ? '{d}Added to the workspace sprint list{d}'
+          : `{d}Added to board "${sprint.board}"'s own sprint list{d}`
+      ));
+    }
   })
   .catch(error => {
     utility.error(error);
@@ -56,11 +69,22 @@ function startSprint(name, description) {
 
 module.exports = async args => {
 
-  // Make sure kanbn has been initialised
-  if (!await kanbn.initialised()) {
-    utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
+    return;
+  }
+  kanbn = scoped;
+
+  let index;
+  try {
+    index = await kanbn.getIndex();
+  } catch (error) {
+    utility.error(error);
     return;
   }
+  const verbose = kanbn.isVerbose(index);
+  const secondaryBoard = !(await kanbn.isMainBoard());
 
   // Get sprint settings from arguments
   // Name
@@ -79,7 +103,7 @@ module.exports = async args => {
   if (args.interactive) {
     interactive(name, description)
     .then(answers => {
-      startSprint(answers.name, answers.description || '');
+      startSprint(answers.name, answers.description || '', verbose, secondaryBoard);
     })
     .catch(error => {
       utility.error(error);
@@ -87,6 +111,6 @@ module.exports = async args => {
 
   // Otherwise start sprint non-interactively
   } else {
-    startSprint(name, description);
+    startSprint(name, description, verbose, secondaryBoard);
   }
 };

package/src/controller/status.js

@@ -1,15 +1,19 @@
-const kanbn = require('../main');
+const workspace = require('../main');
 const utility = require('../utility');
 const chrono = require('chrono-node');
 const yaml = require('yamljs');
 
+// The board this command targets - set from --board before anything else runs
+let kanbn = workspace;
+
 module.exports = async args => {
 
-  // Make sure kanbn has been initialised
-  if (!await kanbn.initialised()) {
-    utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+  // Work out which board this command targets
+  const scoped = await utility.resolveBoard(workspace, args);
+  if (scoped === null) {
     return;
   }
+  kanbn = scoped;
 
   // Get sprint number or name
   let sprint = null;