@zoobbe/cli 1.1.1 → 1.2.1

package/src/commands/card.js

@@ -255,6 +255,78 @@ card
     }
   });
 
+card
+  .command('label <cardId>')
+  .description('Add or remove a label on a card')
+  .option('-b, --board <boardId>', 'Board ID (auto-detected from card if not specified)')
+  .option('-r, --remove', 'Remove the label instead of adding it')
+  .action(async (cardId, options) => {
+    try {
+      // Fetch card to get board info
+      const cardData = await withSpinner('Fetching card...', () =>
+        client.get(`/cards/${cardId}`)
+      );
+      const c = cardData.card || cardData.data || cardData;
+      const boardId = options.board || c.boardShortId || c.board;
+
+      if (!boardId) {
+        return error('Could not determine board. Use -b <boardId>.');
+      }
+
+      // Get available labels from the board
+      const labelsData = await client.get(`/boards/${boardId}/labels`);
+      const labels = labelsData.labels || labelsData.data || labelsData;
+      const labelArr = Array.isArray(labels) ? labels : [];
+
+      if (labelArr.length === 0) {
+        return error('No labels found on this board.');
+      }
+
+      // Get current card labels
+      const cardLabelsData = await client.get(`/cards/${cardId}/labels`);
+      const cardLabels = cardLabelsData.labels || cardLabelsData.data || [];
+      const cardLabelIds = new Set(cardLabels.map(l => l._id));
+
+      // Show available labels with status
+      console.log();
+      console.log(chalk.bold('  Available labels:'));
+      labelArr.forEach((l, i) => {
+        const active = cardLabelIds.has(l._id) ? chalk.green(' [active]') : '';
+        const name = l.text || l.color || 'Unnamed';
+        console.log(`  ${i + 1}. ${name}${active}`);
+      });
+      console.log();
+
+      // Prompt user to pick a label
+      const inquirer = require('inquirer');
+      const { labelIndex } = await inquirer.prompt([{
+        type: 'input',
+        name: 'labelIndex',
+        message: options.remove ? 'Label # to remove:' : 'Label # to add:',
+        validate: v => {
+          const n = parseInt(v);
+          return (n >= 1 && n <= labelArr.length) ? true : `Enter 1-${labelArr.length}`;
+        },
+      }]);
+
+      const label = labelArr[parseInt(labelIndex) - 1];
+
+      if (options.remove) {
+        await withSpinner('Removing label...', () =>
+          client.delete(`/cards/${cardId}/labels/${label._id}`)
+        );
+        success(`Removed label "${label.text || label.color}" from card ${cardId}`);
+      } else {
+        await withSpinner('Adding label...', () =>
+          client.put(`/cards/${cardId}/labels/${label._id}`, { boardId })
+        );
+        success(`Added label "${label.text || label.color}" to card ${cardId}`);
+      }
+    } catch (err) {
+      error(`Failed to update label: ${err.message}`);
+    }
+  });
+
 card
   .command('done <cardId>')
   .description('Mark a card as complete')
@@ -299,4 +371,299 @@ card
     }
   });
 
+// ── Extended commands ──
+
+const { confirmAction } = require('../utils/prompts');
+const { formatRelativeTime } = require('../utils/format');
+
+card
+  .command('update <cardId>')
+  .description('Update card title or description')
+  .option('-t, --title <title>', 'New title')
+  .option('-d, --description <desc>', 'New description')
+  .action(async (cardId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.title = options.title;
+      if (options.description) body.description = options.description;
+      if (Object.keys(body).length === 0) return error('Provide -t or -d.');
+
+      await withSpinner('Updating card...', () =>
+        client.post(`/cards/update/${cardId}`, body)
+      );
+      success(`Updated card ${cardId}`);
+    } catch (err) {
+      error(`Failed to update card: ${err.message}`);
+    }
+  });
+
+card
+  .command('archive <cardId>')
+  .description('Archive a card')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Archiving card...', () =>
+        client.post(`/cards/archive/${cardId}`)
+      );
+      success(`Archived card ${cardId}`);
+    } catch (err) {
+      error(`Failed to archive card: ${err.message}`);
+    }
+  });
+
+card
+  .command('delete <cardId>')
+  .description('Permanently delete a card')
+  .option('--force', 'Skip confirmation')
+  .action(async (cardId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Permanently delete this card and all its data?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting card...', () =>
+        client.post(`/cards/delete/${cardId}`)
+      );
+      success(`Deleted card ${cardId}`);
+    } catch (err) {
+      error(`Failed to delete card: ${err.message}`);
+    }
+  });
+
+card
+  .command('copy <cardId>')
+  .description('Copy a card')
+  .option('-l, --list <listId>', 'Target list ID (copies to same list if omitted)')
+  .action(async (cardId, options) => {
+    try {
+      const body = {};
+      if (options.list) body.targetListId = options.list;
+
+      const data = await withSpinner('Copying card...', () =>
+        client.post(`/cards/${cardId}/copy`, body)
+      );
+      const c = data.card || data.data || data;
+      success(`Copied card to: ${chalk.bold(c.title || 'Copy')} (${c.shortId || c._id})`);
+    } catch (err) {
+      error(`Failed to copy card: ${err.message}`);
+    }
+  });
+
+card
+  .command('unassign <cardId>')
+  .description('Remove a user from a card')
+  .option('-u, --user <userId>', 'User ID to remove (required)')
+  .action(async (cardId, options) => {
+    try {
+      if (!options.user) return error('User ID is required. Use -u <userId>.');
+
+      await withSpinner('Removing member...', () =>
+        client.post(`/cards/${cardId}/removeMember`, { memberId: options.user })
+      );
+      success(`Removed user from card ${cardId}`);
+    } catch (err) {
+      error(`Failed to unassign card: ${err.message}`);
+    }
+  });
+
+card
+  .command('members <cardId>')
+  .description('List members assigned to a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching members...', () =>
+        client.get(`/cards/${cardId}/members`)
+      );
+
+      const members = data.members || data.data || data;
+      const rows = (Array.isArray(members) ? members : []).map(m => {
+        const user = m.user || m;
+        return {
+          name: user.userName || user.username || user.name || 'N/A',
+          email: user.email || 'N/A',
+          id: user._id || user.id || '',
+        };
+      });
+
+      output(rows, {
+        headers: ['Name', 'Email', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list members: ${err.message}`);
+    }
+  });
+
+card
+  .command('comments <cardId>')
+  .description('List comments on a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching comments...', () =>
+        client.get(`/cards/${cardId}/comments`)
+      );
+
+      const comments = data.comments || data.data || data;
+      const rows = (Array.isArray(comments) ? comments : []).map(c => ({
+        user: c.member?.userName || c.user?.userName || 'N/A',
+        comment: (c.comment || '').substring(0, 80),
+        time: formatRelativeTime(c.createdAt),
+        id: c._id,
+      }));
+
+      output(rows, {
+        headers: ['User', 'Comment', 'Time', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list comments: ${err.message}`);
+    }
+  });
+
+card
+  .command('watch <cardId>')
+  .description('Toggle watch on a card')
+  .option('--unwatch', 'Unwatch the card')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner(options.unwatch ? 'Unwatching...' : 'Watching...', () =>
+        client.post(`/cards/${cardId}/watch`)
+      );
+      success(data.message || 'Watch toggled');
+    } catch (err) {
+      error(`Failed to toggle watch: ${err.message}`);
+    }
+  });
+
+card
+  .command('attachments <cardId>')
+  .description('List attachments on a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching attachments...', () =>
+        client.get(`/cards/attachments/${cardId}`)
+      );
+
+      const attachments = data.attachments || data.data || data;
+      const rows = (Array.isArray(attachments) ? attachments : []).map(a => ({
+        name: a.name || a.filename || 'N/A',
+        type: a.type || a.mimetype || '-',
+        size: a.size ? `${Math.round(a.size / 1024)}KB` : '-',
+        id: a._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'Type', 'Size', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list attachments: ${err.message}`);
+    }
+  });
+
+card
+  .command('attach <cardId> <filePath>')
+  .description('Upload an attachment to a card')
+  .action(async (cardId, filePath) => {
+    try {
+      const fs = require('fs');
+      if (!fs.existsSync(filePath)) {
+        return error(`File not found: ${filePath}`);
+      }
+
+      const data = await withSpinner('Uploading attachment...', () =>
+        client.upload(`/cards/attachments/${cardId}`, filePath)
+      );
+      const a = data.attachment || data.data || data;
+      success(`Uploaded: ${chalk.bold(a.name || a.filename || filePath)}`);
+    } catch (err) {
+      error(`Failed to upload attachment: ${err.message}`);
+    }
+  });
+
+card
+  .command('activities <cardId>')
+  .description('Show card activity log')
+  .option('--limit <n>', 'Number of activities', '20')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching activities...', () =>
+        client.get(`/cards/${cardId}/activities`)
+      );
+
+      const activities = data.activities || data.data || data;
+      const actArr = Array.isArray(activities) ? activities : [];
+      const limited = actArr.slice(0, parseInt(options.limit));
+
+      const rows = limited.map(a => ({
+        action: a.action || a.type || 'unknown',
+        user: a.user?.userName || a.user?.name || 'N/A',
+        detail: (a.detail || a.description || '').substring(0, 60),
+        time: formatRelativeTime(a.createdAt),
+      }));
+
+      output(rows, {
+        headers: ['Action', 'User', 'Detail', 'Time'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch activities: ${err.message}`);
+    }
+  });
+
+card
+  .command('due <cardId> <date>')
+  .description('Set or remove a due date on a card')
+  .option('--remove', 'Remove the due date')
+  .action(async (cardId, date, options) => {
+    try {
+      if (options.remove) {
+        await withSpinner('Removing due date...', () =>
+          client.delete(`/cards/${cardId}/duedate`)
+        );
+        success(`Removed due date from card ${cardId}`);
+      } else {
+        await withSpinner('Setting due date...', () =>
+          client.post(`/cards/${cardId}/duedate`, { dueDate: date })
+        );
+        success(`Set due date to ${chalk.bold(date)} on card ${cardId}`);
+      }
+    } catch (err) {
+      error(`Failed to update due date: ${err.message}`);
+    }
+  });
+
+card
+  .command('priority <cardId> <level>')
+  .description('Set card priority (low|medium|high|critical)')
+  .action(async (cardId, level) => {
+    try {
+      await withSpinner('Setting priority...', () =>
+        client.post(`/cards/${cardId}/priority`, { priority: level })
+      );
+      success(`Set priority to ${chalk.bold(level)} on card ${cardId}`);
+    } catch (err) {
+      error(`Failed to set priority: ${err.message}`);
+    }
+  });
+
+card
+  .command('undone <cardId>')
+  .description('Mark a card as incomplete')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Updating card...', () =>
+        client.post(`/cards/update/${cardId}`, { isComplete: false })
+      );
+      success(`Card ${cardId} marked as incomplete`);
+    } catch (err) {
+      error(`Failed to update card: ${err.message}`);
+    }
+  });
+
 module.exports = card;

package/src/commands/checklist.js

@@ -0,0 +1,173 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const client = require('../lib/client');
+const { output, success, error } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { confirmAction } = require('../utils/prompts');
+
+const checklist = new Command('checklist')
+  .alias('cl')
+  .description('Card checklist management commands');
+
+checklist
+  .command('list <cardId>')
+  .alias('ls')
+  .description('List checklists on a card')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (cardId, options) => {
+    try {
+      const data = await withSpinner('Fetching checklists...', () =>
+        client.get(`/cards/${cardId}/checklists`)
+      );
+
+      const checklists = data.checklists || data.data || data;
+      const clArr = Array.isArray(checklists) ? checklists : [];
+
+      if (clArr.length === 0) {
+        return error('No checklists on this card.');
+      }
+
+      // Display checklists with items
+      for (const cl of clArr) {
+        const items = cl.items || [];
+        const done = items.filter(i => i.checked).length;
+        console.log();
+        console.log(`  ${chalk.bold(cl.title)} (${cl._id}) — ${done}/${items.length} done`);
+        for (const item of items) {
+          const check = item.checked ? chalk.green('✓') : chalk.gray('○');
+          console.log(`    ${check} ${item.title} ${chalk.gray(`(${item._id})`)}`);
+        }
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed to list checklists: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('add <cardId> <title>')
+  .description('Add a checklist to a card')
+  .action(async (cardId, title) => {
+    try {
+      const data = await withSpinner('Adding checklist...', () =>
+        client.post(`/cards/${cardId}/checklists`, { title })
+      );
+      const cl = data.checklist || data.data || data;
+      success(`Added checklist: ${chalk.bold(title)} (${cl._id})`);
+    } catch (err) {
+      error(`Failed to add checklist: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('rename <cardId> <checklistId>')
+  .description('Rename a checklist')
+  .option('-t, --title <title>', 'New title (required)')
+  .action(async (cardId, checklistId, options) => {
+    try {
+      if (!options.title) return error('Title is required. Use -t <title>.');
+
+      await withSpinner('Renaming checklist...', () =>
+        client.put(`/cards/${cardId}/checklists/${checklistId}`, { title: options.title })
+      );
+      success(`Renamed checklist to: ${chalk.bold(options.title)}`);
+    } catch (err) {
+      error(`Failed to rename checklist: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('delete <cardId> <checklistId>')
+  .description('Delete a checklist')
+  .option('--force', 'Skip confirmation')
+  .action(async (cardId, checklistId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Delete this checklist and all its items?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting checklist...', () =>
+        client.delete(`/cards/${cardId}/checklists/${checklistId}`)
+      );
+      success(`Deleted checklist ${checklistId}`);
+    } catch (err) {
+      error(`Failed to delete checklist: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('add-item <cardId> <checklistId> <title>')
+  .description('Add an item to a checklist')
+  .action(async (cardId, checklistId, title) => {
+    try {
+      await withSpinner('Adding item...', () =>
+        client.post(`/cards/${cardId}/checklists/${checklistId}/items`, { title })
+      );
+      success(`Added item: ${chalk.bold(title)}`);
+    } catch (err) {
+      error(`Failed to add item: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('check <cardId> <checklistId> <itemId>')
+  .description('Toggle an item as complete/incomplete')
+  .action(async (cardId, checklistId, itemId) => {
+    try {
+      // Fetch current state to toggle
+      const data = await client.get(`/cards/${cardId}/checklists`);
+      const checklists = data.checklists || data.data || data;
+      let currentChecked = false;
+      for (const cl of (Array.isArray(checklists) ? checklists : [])) {
+        if (cl._id === checklistId) {
+          const item = (cl.items || []).find(i => i._id === itemId);
+          if (item) currentChecked = item.checked;
+        }
+      }
+
+      await withSpinner('Toggling item...', () =>
+        client.put(`/cards/${cardId}/checklists/${checklistId}/items/${itemId}`, {
+          checked: !currentChecked,
+        })
+      );
+      success(!currentChecked ? 'Item marked as complete' : 'Item marked as incomplete');
+    } catch (err) {
+      error(`Failed to toggle item: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('update-item <cardId> <checklistId> <itemId>')
+  .description('Update a checklist item title')
+  .option('-t, --title <title>', 'New title (required)')
+  .action(async (cardId, checklistId, itemId, options) => {
+    try {
+      if (!options.title) return error('Title is required. Use -t <title>.');
+
+      await withSpinner('Updating item...', () =>
+        client.put(`/cards/${cardId}/checklists/${checklistId}/items/${itemId}`, {
+          title: options.title,
+        })
+      );
+      success(`Updated item to: ${chalk.bold(options.title)}`);
+    } catch (err) {
+      error(`Failed to update item: ${err.message}`);
+    }
+  });
+
+checklist
+  .command('delete-item <cardId> <checklistId> <itemId>')
+  .description('Delete a checklist item')
+  .action(async (cardId, checklistId, itemId) => {
+    try {
+      await withSpinner('Deleting item...', () =>
+        client.delete(`/cards/${cardId}/checklists/${checklistId}/items/${itemId}`)
+      );
+      success('Deleted checklist item');
+    } catch (err) {
+      error(`Failed to delete item: ${err.message}`);
+    }
+  });
+
+module.exports = checklist;

package/src/commands/import.js

@@ -0,0 +1,101 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { output, success, error } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { formatRelativeTime } = require('../utils/format');
+
+const importCmd = new Command('import')
+  .description('Import data from external services');
+
+importCmd
+  .command('trello')
+  .description('Import boards from Trello')
+  .option('--key <key>', 'Trello API key (required)')
+  .option('--token <token>', 'Trello token (required)')
+  .action(async (options) => {
+    try {
+      if (!options.key || !options.token) {
+        return error('Both --key and --token are required for Trello import.');
+      }
+
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const data = await withSpinner('Importing from Trello...', () =>
+        client.post('/trello/import', {
+          trelloKey: options.key,
+          trelloToken: options.token,
+          workspaceId,
+        })
+      );
+
+      const job = data.job || data.data || data;
+      success(`Import started: Job ${chalk.bold(job._id || job.jobId || 'created')}`);
+      if (job._id || job.jobId) {
+        console.log(`  Track progress: zoobbe import status ${job._id || job.jobId}`);
+      }
+    } catch (err) {
+      error(`Failed to import from Trello: ${err.message}`);
+    }
+  });
+
+importCmd
+  .command('status <jobId>')
+  .description('Check import job status')
+  .action(async (jobId) => {
+    try {
+      const data = await withSpinner('Fetching job status...', () =>
+        client.get(`/import/jobs/${jobId}`)
+      );
+
+      const job = data.job || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Job ID:   '), job._id || jobId);
+      console.log(chalk.bold('  Status:   '), job.status || 'unknown');
+      console.log(chalk.bold('  Progress: '), `${job.progress ?? 0}%`);
+      if (job.boardsImported) {
+        console.log(chalk.bold('  Boards:   '), job.boardsImported);
+      }
+      if (job.cardsImported) {
+        console.log(chalk.bold('  Cards:    '), job.cardsImported);
+      }
+      if (job.error) {
+        console.log(chalk.bold('  Error:    '), chalk.red(job.error));
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed to get job status: ${err.message}`);
+    }
+  });
+
+importCmd
+  .command('jobs')
+  .description('List import jobs')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching jobs...', () =>
+        client.get('/import/jobs')
+      );
+
+      const jobs = data.jobs || data.data || data;
+      const rows = (Array.isArray(jobs) ? jobs : []).map(j => ({
+        source: j.source || 'trello',
+        status: j.status || 'unknown',
+        progress: `${j.progress ?? 0}%`,
+        created: formatRelativeTime(j.createdAt),
+        id: j._id,
+      }));
+
+      output(rows, {
+        headers: ['Source', 'Status', 'Progress', 'Created', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list jobs: ${err.message}`);
+    }
+  });
+
+module.exports = importCmd;