@zoobbe/cli 1.2.0 → 1.2.2

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;

package/src/commands/list.js

@@ -0,0 +1,213 @@
+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 { confirmAction } = require('../utils/prompts');
+
+const list = new Command('list')
+  .alias('l')
+  .description('Action list (column) management commands');
+
+list
+  .command('ls')
+  .description('List all lists on a board')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('-a, --all', 'Include archived lists')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching lists...', () =>
+        client.get(`/${options.board}/actionLists/`)
+      );
+
+      let lists = data.lists || data.data || data;
+      lists = Array.isArray(lists) ? lists : Object.values(lists);
+      if (!options.all) {
+        lists = lists.filter(l => !l.archived);
+      }
+
+      const rows = lists.map(l => ({
+        title: l.title || 'Untitled',
+        id: l._id,
+        cards: String(l.cards?.length || 0),
+        color: l.color || '-',
+        status: l.archived ? chalk.yellow('archived') : chalk.green('active'),
+      }));
+
+      output(rows, {
+        headers: ['Title', 'ID', 'Cards', 'Color', 'Status'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list lists: ${err.message}`);
+    }
+  });
+
+list
+  .command('create <title>')
+  .description('Create a new list on a board')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (title, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Creating list...', () =>
+        client.post('/actionLists', { title, boardId: options.board })
+      );
+
+      const l = data.actionList || data.data || data;
+      success(`Created list: ${chalk.bold(title)} (${l._id})`);
+    } catch (err) {
+      error(`Failed to create list: ${err.message}`);
+    }
+  });
+
+list
+  .command('update <listId>')
+  .description('Update a list')
+  .option('-t, --title <title>', 'New title')
+  .option('--color <color>', 'List color (hex)')
+  .option('--text-color <color>', 'Text color (hex)')
+  .action(async (listId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.title = options.title;
+      if (options.color) body.color = options.color;
+      if (options.textColor) body.textColor = options.textColor;
+
+      if (Object.keys(body).length === 0) {
+        return error('Provide at least one option: -t, --color, or --text-color.');
+      }
+
+      await withSpinner('Updating list...', () =>
+        client.put(`/actionLists/${listId}`, body)
+      );
+      success(`Updated list ${listId}`);
+    } catch (err) {
+      error(`Failed to update list: ${err.message}`);
+    }
+  });
+
+list
+  .command('delete <listId>')
+  .description('Delete a list and all its cards')
+  .option('--force', 'Skip confirmation')
+  .action(async (listId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('This will delete the list and all its cards. Continue?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting list...', () =>
+        client.delete(`/actionLists/${listId}`)
+      );
+      success(`Deleted list ${listId}`);
+    } catch (err) {
+      error(`Failed to delete list: ${err.message}`);
+    }
+  });
+
+list
+  .command('archive <listId>')
+  .description('Archive or unarchive a list')
+  .option('--unarchive', 'Unarchive the list')
+  .action(async (listId, options) => {
+    try {
+      const archived = !options.unarchive;
+      await withSpinner(archived ? 'Archiving list...' : 'Unarchiving list...', () =>
+        client.put(`/actionLists/archive/${listId}`, { archivedStatus: archived })
+      );
+      success(archived ? `Archived list ${listId}` : `Unarchived list ${listId}`);
+    } catch (err) {
+      error(`Failed to archive list: ${err.message}`);
+    }
+  });
+
+list
+  .command('archive-cards <listId>')
+  .description('Archive all cards in a list')
+  .option('--force', 'Skip confirmation')
+  .action(async (listId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Archive all cards in this list?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Archiving cards...', () =>
+        client.post(`/actionLists/${listId}/cards/archived`)
+      );
+      success(`Archived all cards in list ${listId}`);
+    } catch (err) {
+      error(`Failed to archive cards: ${err.message}`);
+    }
+  });
+
+list
+  .command('copy <listId>')
+  .description('Copy a list with all its cards')
+  .option('-t, --title <title>', 'Title for the copy')
+  .action(async (listId, options) => {
+    try {
+      const body = {};
+      if (options.title) body.newTitle = options.title;
+
+      const data = await withSpinner('Copying list...', () =>
+        client.post(`/actionLists/${listId}/copy`, body)
+      );
+      const copied = data.copiedList || data.data || data;
+      success(`Copied list to: ${chalk.bold(copied.title || 'Copy')}`);
+    } catch (err) {
+      error(`Failed to copy list: ${err.message}`);
+    }
+  });
+
+list
+  .command('watch <listId>')
+  .description('Toggle watch on a list')
+  .action(async (listId) => {
+    try {
+      const data = await withSpinner('Toggling watch...', () =>
+        client.post(`/actionLists/${listId}/watch`)
+      );
+      success(data.message || 'Watch toggled');
+    } catch (err) {
+      error(`Failed to toggle watch: ${err.message}`);
+    }
+  });
+
+list
+  .command('archived')
+  .description('Show archived lists for a board')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching archived lists...', () =>
+        client.get(`/${options.board}/lists/archived/`)
+      );
+
+      const lists = data.lists || data.data || data;
+      const rows = (Array.isArray(lists) ? lists : []).map(l => ({
+        title: l.title || 'Untitled',
+        id: l._id,
+        cards: String(l.cards?.length || 0),
+      }));
+
+      output(rows, {
+        headers: ['Title', 'ID', 'Cards'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch archived lists: ${err.message}`);
+    }
+  });
+
+module.exports = list;

package/src/commands/notification.js

@@ -0,0 +1,92 @@
+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 { formatRelativeTime } = require('../utils/format');
+
+const notification = new Command('notification')
+  .alias('n')
+  .description('Notification management commands');
+
+notification
+  .command('list')
+  .alias('ls')
+  .description('List notifications')
+  .option('--limit <n>', 'Number of notifications', '20')
+  .option('--unread', 'Show only unread notifications')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      let url = `/notifications?limit=${options.limit}`;
+      if (options.unread) url += '&unread=true';
+
+      const data = await withSpinner('Fetching notifications...', () =>
+        client.get(url)
+      );
+
+      const notifications = data.notifications || data.data || data;
+      const rows = (Array.isArray(notifications) ? notifications : []).map(n => ({
+        type: n.type || n.action || 'notification',
+        message: (n.message || n.text || '').substring(0, 60),
+        read: n.read ? chalk.gray('read') : chalk.blue('unread'),
+        time: formatRelativeTime(n.createdAt),
+        id: n._id,
+      }));
+
+      output(rows, {
+        headers: ['Type', 'Message', 'Status', 'Time', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list notifications: ${err.message}`);
+    }
+  });
+
+notification
+  .command('count')
+  .description('Show unread notification count')
+  .action(async () => {
+    try {
+      const data = await withSpinner('Fetching count...', () =>
+        client.get('/notifications/count')
+      );
+
+      const count = data.count ?? data.unread ?? data.data ?? 0;
+      console.log();
+      console.log(`  ${chalk.bold('Unread notifications:')} ${count}`);
+      console.log();
+    } catch (err) {
+      error(`Failed to get notification count: ${err.message}`);
+    }
+  });
+
+notification
+  .command('read <notificationId>')
+  .description('Mark a notification as read')
+  .action(async (notificationId) => {
+    try {
+      await withSpinner('Marking as read...', () =>
+        client.put(`/notifications/${notificationId}`)
+      );
+      success('Notification marked as read');
+    } catch (err) {
+      error(`Failed to mark notification: ${err.message}`);
+    }
+  });
+
+notification
+  .command('read-all')
+  .description('Mark all notifications as read')
+  .action(async () => {
+    try {
+      await withSpinner('Marking all as read...', () =>
+        client.put('/notifications/mark-all-read')
+      );
+      success('All notifications marked as read');
+    } catch (err) {
+      error(`Failed to mark all: ${err.message}`);
+    }
+  });
+
+module.exports = notification;