@basementuniverse/kanbn 0.10.0 → 1.0.0

package/src/controller/add.js

@@ -23,6 +23,11 @@ async function interactiveCreateTask(taskData, taskIds, columnName, columnNames)
     'due' in taskData.metadata &&
     taskData.metadata.due != null
   );
+  const postponedDateExists = (
+    'metadata' in taskData &&
+    'postponed' in taskData.metadata &&
+    taskData.metadata.postponed != null
+  );
   const assignedExists = (
     'metadata' in taskData &&
     'assigned' in taskData.metadata &&
@@ -76,6 +81,21 @@ async function interactiveCreateTask(taskData, taskIds, columnName, columnNames)
       format: ['Y', '/', 'MM', '/', 'DD'],
       when: answers => answers.setDue,
     },
+    {
+      type: 'confirm',
+      name: 'setPostponed',
+      message: 'Set a postponed date?',
+      default: false,
+      when: answers => !postponedDateExists
+    },
+    {
+      type: 'datepicker',
+      name: 'postponed',
+      message: 'Postponed date:',
+      default: postponedDateExists ? taskData.metadata.postponed : new Date(),
+      format: ['Y', '/', 'MM', '/', 'DD'],
+      when: answers => answers.setPostponed,
+    },
     {
       type: 'confirm',
       name: 'setAssigned',
@@ -323,6 +343,15 @@ module.exports = async args => {
     }
   }
 
+  // Postponed date
+  if (args.postponed) {
+    taskData.metadata.postponed = chrono.parseDate(utility.strArg(args.postponed));
+    if (taskData.metadata.postponed === null) {
+      utility.error('Unable to parse postponed date');
+      return;
+    }
+  }
+
   // Progress
   if (args.progress) {
     const progressValue = parseFloat(utility.strArg(args.progress));
@@ -450,7 +479,10 @@ module.exports = async args => {
         taskData.description = answers.description;
       }
       if ('due' in answers) {
-        taskData.metadata.due = answers.due.toISOString();
+        taskData.metadata.due = answers.due;
+      }
+      if ('postponed' in answers) {
+        taskData.metadata.postponed = answers.postponed;
       }
       if ('assigned' in answers) {
         taskData.metadata.assigned = answers.assigned;

package/src/controller/burndown.js

@@ -5,6 +5,61 @@ const term = require('terminal-kit').terminal;
 const chrono = require('chrono-node');
 const formatDate = require('dateformat');
 
+const getLabelPlacements = (from, to, width, dateFormat, maxLabels) => {
+  for (let count = maxLabels; count >= 1; count--) {
+    const placements = [];
+    let previousEnd = -1;
+
+    for (let i = 0; i < count; i++) {
+      const ratio = count === 1 ? 0 : i / (count - 1);
+      const position = Math.round(ratio * (width - 1));
+      const value = new Date(from.getTime() + Math.round((to.getTime() - from.getTime()) * ratio));
+      const label = formatDate(value, dateFormat);
+
+      let start = position - Math.floor(label.length / 2);
+      if (start < 0) {
+        start = 0;
+      }
+      if (start + label.length > width) {
+        start = Math.max(0, width - label.length);
+      }
+
+      const end = start + label.length - 1;
+      if (i > 0 && start <= previousEnd + 1) {
+        placements.length = 0;
+        break;
+      }
+
+      placements.push({ position, start, label, end });
+      previousEnd = end;
+    }
+
+    if (placements.length) {
+      return placements;
+    }
+  }
+
+  return [];
+};
+
+const renderXAxisLabels = (from, to, width, dateFormat, leftPadding) => {
+  const sampleLabel = formatDate(from, dateFormat);
+  const maxLabels = Math.max(1, Math.floor((width + 2) / (sampleLabel.length + 2)));
+  const placements = getLabelPlacements(from, to, width, dateFormat, maxLabels);
+
+  const ticks = Array(width).fill(' ');
+  const labels = Array(width).fill(' ');
+
+  for (const placement of placements) {
+    ticks[placement.position] = '|';
+    for (let i = 0; i < placement.label.length; i++) {
+      labels[placement.start + i] = placement.label[i];
+    }
+  }
+
+  return `${leftPadding}${ticks.join('')}\n${leftPadding}${labels.join('')}`;
+};
+
 module.exports = async args => {
 
   // Make sure kanbn has been initialised
@@ -72,18 +127,23 @@ module.exports = async args => {
 
       // Render chart
       const PADDING = '     ';
-      const width = term.width - (PADDING.length + 1);
+      const width = Math.max(1, term.width - (PADDING.length + 1));
 
       const plots = [];
-      for (s of data.series) {
-        const plot = [], delta = Math.floor((s.to.getTime() - s.from.getTime()) / width);
+      for (const s of data.series) {
+        const plot = [];
+        const span = Math.max(1, s.to.getTime() - s.from.getTime());
+        const delta = width > 1 ? span / (width - 1) : 0;
         for (let i = 0; i < width; i++) {
-          plot.push((s.dataPoints.find(d => d.x >= new Date(s.from.getTime() + i * delta)) || s.dataPoints[0]).y);
+          const x = new Date(s.from.getTime() + Math.round(i * delta));
+          plot.push((s.dataPoints.find(d => d.x >= x) || s.dataPoints[0]).y);
         }
         plots.push(plot);
       }
+
+      const referenceSeries = data.series[0];
       const dateFormat = kanbn.getDateFormat(index);
-      console.log(`${formatDate(s.from, dateFormat)} to ${formatDate(s.to, dateFormat)}:`);
+      console.log(`${formatDate(referenceSeries.from, dateFormat)} to ${formatDate(referenceSeries.to, dateFormat)}:`);
       console.log(asciichart.plot(
         plots,
         {
@@ -99,6 +159,13 @@ module.exports = async args => {
           ]
         }
       ));
+      console.log(renderXAxisLabels(
+        referenceSeries.from,
+        referenceSeries.to,
+        width,
+        dateFormat,
+        ' '.repeat(PADDING.length + 1)
+      ));
     }
   })
   .catch(error => {

package/src/controller/edit.js

@@ -23,6 +23,11 @@ async function interactive(taskData, taskIds, columnName, columnNames) {
     'due' in taskData.metadata &&
     taskData.metadata.due != null
   );
+  const postponedDateExists = (
+    'metadata' in taskData &&
+    'postponed' in taskData.metadata &&
+    taskData.metadata.postponed != null
+  );
   const assignedExists = (
     'metadata' in taskData &&
     'assigned' in taskData.metadata &&
@@ -101,6 +106,46 @@ async function interactive(taskData, taskIds, columnName, columnNames) {
       format: ['Y', '/', 'MM', '/', 'DD'],
       when: answers => answers.setDue || answers.editDue === 'edit'
     },
+    {
+      type: 'expand',
+      name: 'editPostponed',
+      message: 'Edit or remove postponed date?',
+      default: 'none',
+      when: answers => postponedDateExists,
+      choices: [
+        {
+          key: 'e',
+          name: 'Edit',
+          value: 'edit'
+        },
+        {
+          key: 'r',
+          name: 'Remove',
+          value: 'remove'
+        },
+        new inquirer.Separator(),
+        {
+          key: 'n',
+          name: 'Do nothing',
+          value: 'none'
+        }
+      ]
+    },
+    {
+      type: 'confirm',
+      name: 'setPostponed',
+      message: 'Set a postponed date?',
+      default: false,
+      when: answers => !postponedDateExists
+    },
+    {
+      type: 'datepicker',
+      name: 'postponed',
+      message: 'Postponed date:',
+      default: postponedDateExists ? taskData.metadata.postponed : new Date(),
+      format: ['Y', '/', 'MM', '/', 'DD'],
+      when: answers => answers.setPostponed || answers.editPostponed === 'edit'
+    },
     {
       type: 'expand',
       name: 'editAssigned',
@@ -430,6 +475,18 @@ module.exports = async args => {
     }
   }
 
+  // Postponed date
+  if (args.postponed) {
+    if (!('metadata' in taskData)) {
+      taskData.metadata = {};
+    }
+    taskData.metadata.postponed = chrono.parseDate(utility.strArg(args.postponed));
+    if (taskData.metadata.postponed === null) {
+      utility.error('Unable to parse postponed date');
+      return;
+    }
+  }
+
   // Progress
   if (args.progress) {
     if (!('metadata' in taskData)) {
@@ -660,7 +717,17 @@ module.exports = async args => {
 
       // Due date
       if ('due' in answers) {
-        taskData.metadata.due = answers.due.toISOString();
+        taskData.metadata.due = answers.due;
+      }
+
+      // Remove postponed date
+      if ('editPostponed' in answers && answers.editPostponed === 'remove') {
+        delete taskData.metadata.postponed;
+      }
+
+      // Postponed date
+      if ('postponed' in answers) {
+        taskData.metadata.postponed = answers.postponed;
       }
 
       // Remove assigned

package/src/controller/find.js

@@ -52,6 +52,11 @@ const searchFields = [
     field: 'due',
     type: 'date'
   },
+  {
+    name: 'Postponed',
+    field: 'postponed',
+    type: 'date'
+  },
   {
     name: 'Progress',
     field: 'progress',

package/src/controller/gantt.js

@@ -0,0 +1,375 @@
+const kanbn = require('../main');
+const utility = require('../utility');
+const formatDate = require('dateformat');
+const chrono = require('chrono-node');
+
+const NOW_MARKER = '┆';
+const ANSI_RESET = '\x1b[0m';
+const ANSI_FG_LINE = '\x1b[97m';
+const ANSI_FG_NOW = '\x1b[90m';
+const ANSI_BG_NOT_STARTED = '\x1b[100m';
+const ANSI_BG_STARTED = '\x1b[44m';
+const ANSI_BG_COMPLETED = '\x1b[42m';
+
+const DIR_UP = 1;
+const DIR_DOWN = 2;
+const DIR_LEFT = 4;
+const DIR_RIGHT = 8;
+
+const LINE_CHARS = {
+  [DIR_UP]: '│',
+  [DIR_DOWN]: '│',
+  [DIR_LEFT]: '─',
+  [DIR_RIGHT]: '─',
+  [DIR_UP | DIR_DOWN]: '│',
+  [DIR_LEFT | DIR_RIGHT]: '─',
+  [DIR_DOWN | DIR_RIGHT]: '┌',
+  [DIR_DOWN | DIR_LEFT]: '┐',
+  [DIR_UP | DIR_RIGHT]: '└',
+  [DIR_UP | DIR_LEFT]: '┘',
+  [DIR_UP | DIR_DOWN | DIR_RIGHT]: '├',
+  [DIR_UP | DIR_DOWN | DIR_LEFT]: '┤',
+  [DIR_UP | DIR_LEFT | DIR_RIGHT]: '┴',
+  [DIR_DOWN | DIR_LEFT | DIR_RIGHT]: '┬',
+  [DIR_UP | DIR_DOWN | DIR_LEFT | DIR_RIGHT]: '┼'
+};
+
+function getBarGeometry(task, from, to, width) {
+  if (width <= 1 || from.getTime() === to.getTime()) {
+    return { start: 0, end: 0 };
+  }
+
+  // Calculate the position in the chart
+  const totalSpan = to.getTime() - from.getTime();
+  const taskStartPos = Math.max(0, Math.round((task.start.getTime() - from.getTime()) / totalSpan * (width - 1)));
+  const taskEndPos = Math.min(width - 1, Math.round((task.end.getTime() - from.getTime()) / totalSpan * (width - 1)));
+
+  return {
+    start: taskStartPos,
+    end: taskEndPos
+  };
+}
+
+function getBarBackground(task) {
+  if (task.completed instanceof Date) {
+    return ANSI_BG_COMPLETED;
+  }
+  if (task.started instanceof Date) {
+    return ANSI_BG_STARTED;
+  }
+  return ANSI_BG_NOT_STARTED;
+}
+
+function createChartCell() {
+  return {
+    bg: null,
+    lineMask: 0,
+    arrowChar: null
+  };
+}
+
+function createChartGrid(height, width) {
+  return Array.from({ length: height }, () => Array.from({ length: width }, createChartCell));
+}
+
+function addMask(cell, mask) {
+  cell.lineMask |= mask;
+}
+
+function addHorizontalConnection(grid, row, fromCol, toCol) {
+  if (fromCol === toCol) {
+    return;
+  }
+
+  const step = fromCol < toCol ? 1 : -1;
+  for (let col = fromCol; col !== toCol; col += step) {
+    addMask(grid[row][col], step > 0 ? DIR_RIGHT : DIR_LEFT);
+    addMask(grid[row][col + step], step > 0 ? DIR_LEFT : DIR_RIGHT);
+  }
+}
+
+function addVerticalConnection(grid, col, fromRow, toRow) {
+  if (fromRow === toRow) {
+    return;
+  }
+
+  const step = fromRow < toRow ? 1 : -1;
+  for (let row = fromRow; row !== toRow; row += step) {
+    addMask(grid[row][col], step > 0 ? DIR_DOWN : DIR_UP);
+    addMask(grid[row + step][col], step > 0 ? DIR_UP : DIR_DOWN);
+  }
+}
+
+function routeDependency(grid, sourceRow, sourceCol, targetRow, targetCol) {
+  if (sourceRow === null || targetRow === null) {
+    return;
+  }
+
+  if (sourceRow === targetRow) {
+    addHorizontalConnection(grid, sourceRow, sourceCol, targetCol);
+    grid[targetRow][targetCol].arrowChar = targetCol >= sourceCol ? '→' : '←';
+    return;
+  }
+
+  const moveRight = targetCol >= sourceCol;
+  let routeCol = moveRight ? Math.max(sourceCol + 1, targetCol - 1) : Math.min(sourceCol - 1, targetCol + 1);
+  routeCol = Math.max(0, Math.min(grid[0].length - 1, routeCol));
+
+  addHorizontalConnection(grid, sourceRow, sourceCol, routeCol);
+  addVerticalConnection(grid, routeCol, sourceRow, targetRow);
+  addHorizontalConnection(grid, targetRow, routeCol, targetCol);
+  grid[targetRow][targetCol].arrowChar = targetCol >= routeCol ? '→' : '←';
+}
+
+function buildDependencyOverlay(tasks, barGeometries, width) {
+  const grid = createChartGrid(tasks.length, width);
+  const taskRowMap = new Map(tasks.map((task, index) => [task.id, index]));
+
+  tasks.forEach((task, targetRow) => {
+    (task.dependencies || []).forEach((dependencyId) => {
+      const sourceRow = taskRowMap.get(dependencyId);
+      if (sourceRow === undefined) {
+        return;
+      }
+
+      routeDependency(
+        grid,
+        sourceRow,
+        barGeometries[sourceRow].end,
+        targetRow,
+        barGeometries[targetRow].start
+      );
+    });
+  });
+
+  return grid;
+}
+
+function styleCell(char, fg = null, bg = null) {
+  if (!fg && !bg) {
+    return char;
+  }
+
+  return `${fg || ''}${bg || ''}${char}${ANSI_RESET}`;
+}
+
+function renderChartRow(gridRow, barGeometry, barBackground, nowPosition) {
+  return gridRow.map((cell, column) => {
+    const bg = column >= barGeometry.start && column <= barGeometry.end ? barBackground : null;
+    if (cell.arrowChar) {
+      return styleCell(cell.arrowChar, ANSI_FG_LINE, bg);
+    }
+
+    const lineChar = LINE_CHARS[cell.lineMask] || null;
+    if (lineChar) {
+      return styleCell(lineChar, ANSI_FG_LINE, bg);
+    }
+
+    if (nowPosition === column) {
+      return styleCell(NOW_MARKER, ANSI_FG_NOW, bg);
+    }
+
+    return styleCell(' ', null, bg);
+  }).join('');
+}
+
+function renderTickRow(ticks, nowPosition) {
+  return ticks.split('').map((char, column) => {
+    if (char !== ' ') {
+      return styleCell(char, ANSI_FG_LINE, null);
+    }
+    if (nowPosition === column) {
+      return styleCell(NOW_MARKER, ANSI_FG_NOW, null);
+    }
+    return char;
+  }).join('');
+}
+
+function getLabelPlacements(from, to, width, dateFormat, maxLabels) {
+  for (let count = maxLabels; count >= 1; count--) {
+    const placements = [];
+    let previousEnd = -1;
+
+    for (let i = 0; i < count; i++) {
+      const ratio = count === 1 ? 0 : i / (count - 1);
+      const position = Math.round(ratio * (width - 1));
+      const value = new Date(from.getTime() + Math.round((to.getTime() - from.getTime()) * ratio));
+      const label = formatDate(value, dateFormat);
+
+      let start = position - Math.floor(label.length / 2);
+      if (start < 0) {
+        start = 0;
+      }
+      if (start + label.length > width) {
+        start = Math.max(0, width - label.length);
+      }
+
+      const end = start + label.length - 1;
+      if (i > 0 && start <= previousEnd + 1) {
+        placements.length = 0;
+        break;
+      }
+
+      placements.push({ position, start, label, end });
+      previousEnd = end;
+    }
+
+    if (placements.length) {
+      return placements;
+    }
+  }
+
+  return [];
+}
+
+function renderXAxisLabels(from, to, width, dateFormat) {
+  const sampleLabel = formatDate(from, dateFormat);
+  const maxLabels = Math.max(1, Math.floor((width + 2) / (sampleLabel.length + 2)));
+  const placements = getLabelPlacements(from, to, width, dateFormat, maxLabels);
+
+  const ticks = Array(width).fill(' ');
+  const labels = Array(width).fill(' ');
+
+  for (const placement of placements) {
+    ticks[placement.position] = '│';
+    for (let i = 0; i < placement.label.length; i++) {
+      labels[placement.start + i] = placement.label[i];
+    }
+  }
+
+  return [ticks.join(''), labels.join('')];
+}
+
+function getNowPosition(from, to, width, now = new Date()) {
+  if (now < from || now > to) {
+    return null;
+  }
+
+  const totalSpan = to.getTime() - from.getTime();
+  return Math.round((now.getTime() - from.getTime()) / totalSpan * (width - 1));
+}
+
+function renderNowOverlay(line, nowPosition) {
+  if (nowPosition === null || nowPosition < 0 || nowPosition >= line.length) {
+    return line;
+  }
+
+  const result = line.split('');
+  result[nowPosition] = NOW_MARKER;
+  return result.join('');
+}
+
+function truncateName(name, maxWidth) {
+  if (name.length <= maxWidth) {
+    return name;
+  }
+  return name.substring(0, maxWidth - 1) + '…';
+}
+
+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}');
+    return;
+  }
+  const index = await kanbn.getIndex();
+
+  // Get assigned
+  let assigned = null;
+  if (args.assigned) {
+    assigned = utility.strArg(args.assigned);
+  }
+
+  // Get columns
+  let columns = null;
+  if (args.column) {
+    columns = utility.arrayArg(args.column);
+  }
+
+  // Get dates
+  let dates = null;
+  if (args.date) {
+    dates = utility.arrayArg(args.date);
+    if (dates.length) {
+      for (let i = 0; i < dates.length; i++) {
+        const dateValue = chrono.parseDate(dates[i]);
+        if (dateValue === null) {
+          utility.error('Unable to parse date');
+          return;
+        }
+        dates[i] = dateValue;
+      }
+    }
+  }
+
+  // Get mocked now date
+  let now = null;
+  if (args.now) {
+    now = chrono.parseDate(utility.strArg(args.now));
+    if (now === null) {
+      utility.error('Unable to parse now date');
+      return;
+    }
+  }
+
+  // Show gantt chart data
+  kanbn
+  .gantt(assigned, columns, dates, now)
+  .then(data => {
+    if (args.json) {
+
+      // Output raw data
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+
+      // Render chart
+      const dateFormat = kanbn.getDateFormat(index);
+      const maxNameWidth = 16;
+      const nowDate = now || new Date();
+
+      // Keep each rendered task line within terminal width where possible.
+      // Line shape: "<prefix> <name> │<bar>│" => maxNameWidth + barWidth + 5 columns.
+      const terminalWidth = Number.isFinite(process.stdout.columns) && process.stdout.columns > 0
+        ? process.stdout.columns
+        : 120;
+      const barWidth = Math.max(1, terminalWidth - maxNameWidth - 5);
+      const nowPosition = getNowPosition(data.from, data.to, barWidth, nowDate);
+      const barGeometries = data.tasks.map((task) => getBarGeometry(task, data.from, data.to, barWidth));
+      const dependencyOverlay = buildDependencyOverlay(data.tasks, barGeometries, barWidth);
+
+      // Render header
+      console.log(`Gantt chart: ${formatDate(data.from, dateFormat)} to ${formatDate(data.to, dateFormat)}`);
+      if (data.dependencyCycleDetected) {
+        const cycleDescription = Array.isArray(data.dependencyCycleTaskIds) && data.dependencyCycleTaskIds.length
+          ? ` Cycle: ${data.dependencyCycleTaskIds.join(' -> ')}.`
+          : '';
+        console.error(`Warning: dependency cycle detected; using fallback ordering for ${data.cycleFallbackTaskIds.length} task(s).${cycleDescription}`);
+      }
+      console.log('');
+
+      // Render tasks with bars
+      data.tasks.forEach((task, taskIndex) => {
+        const prefix = task.blocked ? '⧗' : ' ';
+        const truncatedName = truncateName(task.name, maxNameWidth);
+        const bar = renderChartRow(
+          dependencyOverlay[taskIndex],
+          barGeometries[taskIndex],
+          getBarBackground(task),
+          nowPosition
+        );
+
+        console.log(`${prefix} ${truncatedName.padEnd(maxNameWidth)} │${bar}│`);
+      });
+
+      // Render x-axis
+      console.log('');
+      const [ticks, labels] = renderXAxisLabels(data.from, data.to, barWidth, dateFormat);
+      console.log(`  ${''.padEnd(maxNameWidth)} │${renderTickRow(ticks, nowPosition)}│`);
+      console.log(`  ${''.padEnd(maxNameWidth)} │${labels}│`);
+    }
+  })
+  .catch(error => {
+    utility.error(error);
+  });
+};

package/src/controller/init.js

@@ -1,4 +1,5 @@
-const kanbn = require('../main');
+const kanbn_module = require('../main');
+const kanbn = new kanbn_module.Kanbn();
 const utility = require('../utility');
 const inquirer = require('inquirer');
 

package/src/controller/sort.js

@@ -122,6 +122,14 @@ const sorterFields = [
     ],
     filterable: false
   },
+  {
+    name: 'Postponed date',
+    field: 'postponed',
+    options: [
+      '--postponed'
+    ],
+    filterable: false
+  },
   {
     name: 'Completed date',
     field: 'completed',