@basementuniverse/kanbn 2.0.0 → 2.1.0

package/src/controller/init.js

@@ -1,8 +1,11 @@
 const kanbn_module = require('../main');
-const kanbn = new kanbn_module.Kanbn();
+const workspace = new kanbn_module.Kanbn();
 const utility = require('../utility');
 const inquirer = require('inquirer');
 
+// The board being initialised - set from --board before anything else runs
+let kanbn = workspace;
+
 inquirer.registerPrompt('recursive', require('inquirer-recursive'));
 
 /**
@@ -73,11 +76,20 @@ async function interactive(options, initialised) {
  * Initialise kanbn
  * @param {object} options
  * @param {boolean} initialised
+ * @param {?string} boardSlug The slug of the board being initialised, or null for the main board
  */
-async function initialise(options, initialised) {
+async function initialise(options, initialised, boardSlug = null) {
   const mainFolder = await kanbn.getMainFolder();
   kanbn.initialise(options)
   .then(() => {
+    if (boardSlug !== null) {
+      console.log(
+        initialised
+          ? `Updated board "${boardSlug}" in ${mainFolder}`
+          : `Created board "${boardSlug}" in ${mainFolder}`
+      );
+      return;
+    }
     if (initialised) {
       console.log(`Reinitialised existing kanbn board in ${mainFolder}`);
     } else {
@@ -92,6 +104,29 @@ async function initialise(options, initialised) {
 module.exports = async args => {
   let options = {};
 
+  // Work out which board we're initialising. Without --board this is the main board, i.e. the whole
+  // workspace, which is exactly what init has always done
+  let boardSlug = null;
+  if (args.board) {
+    boardSlug = utility.strArg(args.board);
+
+    // A secondary board lives beside the main board and shares its tasks, so the workspace has to
+    // exist first
+    if (!await workspace.initialised()) {
+      utility.error('Kanbn has not been initialised in this folder\nTry running: {b}kanbn init{b}');
+      return;
+    }
+    try {
+      boardSlug = await workspace.validateBoardSlug(boardSlug);
+    } catch (error) {
+      utility.error(error);
+      return;
+    }
+    kanbn = workspace.board(boardSlug);
+  } else {
+    kanbn = workspace;
+  }
+
   // If this folder is already initialised, set the default name and description using the current values
   const initialised = await kanbn.initialised();
   if (initialised) {
@@ -129,7 +164,7 @@ module.exports = async args => {
       if ('columns' in answers) {
         answers.columns = answers.columns.map(column => column.columnName);
       }
-      await initialise(answers, initialised);
+      await initialise(answers, initialised, boardSlug);
     })
     .catch(error => {
       utility.error(error);
@@ -137,6 +172,6 @@ module.exports = async args => {
 
   // Non-interactive initialisation
   } else {
-    await initialise(options, initialised);
+    await initialise(options, initialised, boardSlug);
   }
 };

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,9 +45,9 @@ 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}"`);
   })
@@ -53,13 +56,35 @@ function moveTask(taskId, columnName, position = null, relative = false) {
   });
 }
 
+/**
+ * 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}"`);
+  } 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 +93,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 +107,43 @@ module.exports = async args => {
     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;
@@ -138,6 +192,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,47 @@
-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 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}"` : '')
+    );
   })
   .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];
@@ -50,9 +67,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 +88,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,29 @@
-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`);
+
+    // 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 +32,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 +70,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 = [
@@ -275,6 +278,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 +306,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;

package/src/controller/task.js

@@ -1,4 +1,4 @@
-const kanbn = require("../main");
+const workspace = require("../main");
 const utility = require("../utility");
 const parseTask = require("../parse-task");
 const marked = require("marked");
@@ -6,19 +6,31 @@ const markedTerminalRenderer = require("marked-terminal");
 
 /**
  * Show task information
+ * @param {object} kanbn The board-scoped kanbn instance
  * @param {string} taskId
+ * @param {Record<string, string>} boards The boards this task appears on, and the column on each
+ * @param {boolean} json
  */
-function showTask(taskId, json = false) {
+function showTask(kanbn, taskId, boards, json = false) {
   kanbn
     .getTask(taskId)
     .then((task) => {
       if (json) {
-        console.log(JSON.stringify(task, null, 2));
+        console.log(JSON.stringify({ ...task, boards }, null, 2));
       } else {
         marked.setOptions({
           renderer: new markedTerminalRenderer(),
         });
-        console.log(marked(parseTask.json2md(task)));
+
+        // Board membership isn't part of the task file - boards own membership, not tasks - so it's
+        // appended here rather than rendered from the task itself. Only worth showing once there is
+        // more than one board to be a member of
+        const boardSlugs = Object.keys(boards);
+        const boardsSection =
+          boardSlugs.length > 1
+            ? `\n## Boards\n\n${boardSlugs.map((slug) => `- ${slug}: ${boards[slug]}`).join("\n")}\n`
+            : "";
+        console.log(marked.parse(parseTask.json2md(task) + boardsSection));
       }
     })
     .catch((error) => {
@@ -27,9 +39,10 @@ function showTask(taskId, json = false) {
 }
 
 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 kanbn = await utility.resolveBoard(workspace, args);
+  if (kanbn === null) {
     return;
   }
 
@@ -48,6 +61,6 @@ module.exports = async (args) => {
     return;
   }
 
-  // Show the task
-  showTask(taskId, args.json);
+  // Show the task, along with the boards it appears on
+  showTask(kanbn, taskId, await workspace.findTaskBoards(taskId), args.json);
 };