@zoobbe/cli 1.2.0 → 1.2.2

package/src/commands/analytics.js

@@ -0,0 +1,281 @@
+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 { formatDuration } = require('../utils/format');
+
+const analytics = new Command('analytics')
+  .alias('an')
+  .description('Analytics and reporting commands');
+
+analytics
+  .command('board <boardId>')
+  .description('Show board analytics overview')
+  .action(async (boardId) => {
+    try {
+      const data = await withSpinner('Fetching analytics...', () =>
+        client.get(`/analytics/board/${boardId}`)
+      );
+
+      const a = data.analytics || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Board Analytics'));
+      console.log(chalk.bold('  ─────────────────'));
+      console.log(chalk.bold('  Total Cards:     '), a.totalCards ?? 0);
+      console.log(chalk.bold('  Completed:       '), a.completedCards ?? 0);
+      console.log(chalk.bold('  In Progress:     '), a.inProgressCards ?? 0);
+      console.log(chalk.bold('  Overdue:         '), a.overdueCards ?? 0);
+      console.log(chalk.bold('  Members:         '), a.totalMembers ?? 0);
+      console.log(chalk.bold('  Completion Rate: '), `${a.completionRate ?? 0}%`);
+      console.log();
+    } catch (err) {
+      error(`Failed to fetch analytics: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('metrics <boardId>')
+  .description('Show board metrics')
+  .option('--range <range>', 'Time range (7d|30d|90d)', '30d')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (boardId, options) => {
+    try {
+      const data = await withSpinner('Fetching metrics...', () =>
+        client.get(`/analytics/board/${boardId}/metrics?range=${options.range}`)
+      );
+
+      const metrics = data.metrics || data.data || data;
+      if (Array.isArray(metrics)) {
+        const rows = metrics.map(m => ({
+          metric: m.name || m.metric || 'N/A',
+          value: String(m.value ?? 0),
+          change: m.change ? `${m.change > 0 ? '+' : ''}${m.change}%` : '-',
+        }));
+        output(rows, {
+          headers: ['Metric', 'Value', 'Change'],
+          format: options.format,
+        });
+      } else {
+        console.log();
+        for (const [key, val] of Object.entries(metrics)) {
+          console.log(chalk.bold(`  ${key}: `), val);
+        }
+        console.log();
+      }
+    } catch (err) {
+      error(`Failed to fetch metrics: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('time <boardId>')
+  .description('Show time analytics for a board')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (boardId, options) => {
+    try {
+      const data = await withSpinner('Fetching time analytics...', () =>
+        client.get(`/analytics/board/${boardId}/time-analytics`)
+      );
+
+      const time = data.analytics || data.data || data;
+      if (Array.isArray(time)) {
+        const rows = time.map(t => ({
+          list: t.list || t.name || 'N/A',
+          avgTime: t.avgTime ? formatDuration(t.avgTime) : '-',
+          totalCards: String(t.totalCards ?? 0),
+        }));
+        output(rows, {
+          headers: ['List', 'Avg Time', 'Cards'],
+          format: options.format,
+        });
+      } else {
+        console.log();
+        console.log(chalk.bold('  Avg Completion: '), time.avgCompletion ? formatDuration(time.avgCompletion) : 'N/A');
+        console.log(chalk.bold('  Total Tracked:  '), time.totalTracked ? formatDuration(time.totalTracked) : '0s');
+        console.log();
+      }
+    } catch (err) {
+      error(`Failed to fetch time analytics: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('timeline <boardId>')
+  .description('Show full timeline for a board')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (boardId, options) => {
+    try {
+      const data = await withSpinner('Fetching timeline...', () =>
+        client.get(`/analytics/board/${boardId}/full-timeline`)
+      );
+
+      const timeline = data.timeline || data.data || data;
+      const rows = (Array.isArray(timeline) ? timeline : []).map(t => ({
+        date: t.date || 'N/A',
+        created: String(t.created ?? 0),
+        completed: String(t.completed ?? 0),
+        active: String(t.active ?? 0),
+      }));
+
+      output(rows, {
+        headers: ['Date', 'Created', 'Completed', 'Active'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch timeline: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('productivity <boardId>')
+  .description('Show user productivity for a board')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (boardId, options) => {
+    try {
+      const data = await withSpinner('Fetching productivity...', () =>
+        client.get(`/analytics/board/${boardId}/user-productivity`)
+      );
+
+      const users = data.users || data.data || data;
+      const rows = (Array.isArray(users) ? users : []).map(u => ({
+        user: u.userName || u.name || 'N/A',
+        completed: String(u.completedCards ?? 0),
+        assigned: String(u.assignedCards ?? 0),
+        timeTracked: u.timeTracked ? formatDuration(u.timeTracked) : '-',
+      }));
+
+      output(rows, {
+        headers: ['User', 'Completed', 'Assigned', 'Time Tracked'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch productivity: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('workflow <boardId>')
+  .description('Show workflow analytics for a board')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (boardId, options) => {
+    try {
+      const data = await withSpinner('Fetching workflow analytics...', () =>
+        client.get(`/analytics/board/${boardId}/workflow-analytics`)
+      );
+
+      const workflow = data.workflow || data.data || data;
+      const rows = (Array.isArray(workflow) ? workflow : []).map(w => ({
+        list: w.list || w.name || 'N/A',
+        cards: String(w.cardCount ?? 0),
+        avgTime: w.avgTime ? formatDuration(w.avgTime) : '-',
+        throughput: String(w.throughput ?? 0),
+      }));
+
+      output(rows, {
+        headers: ['List', 'Cards', 'Avg Time', 'Throughput'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch workflow analytics: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('workspace')
+  .description('Show workspace analytics')
+  .action(async () => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) return error('No active workspace.');
+
+      const data = await withSpinner('Fetching workspace analytics...', () =>
+        client.get(`/analytics/workspace/${workspaceId}`)
+      );
+
+      const a = data.analytics || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Workspace Analytics'));
+      console.log(chalk.bold('  ─────────────────────'));
+      console.log(chalk.bold('  Total Boards:  '), a.totalBoards ?? 0);
+      console.log(chalk.bold('  Total Cards:   '), a.totalCards ?? 0);
+      console.log(chalk.bold('  Active Members:'), a.activeMembers ?? 0);
+      console.log(chalk.bold('  Completion:    '), `${a.completionRate ?? 0}%`);
+      console.log();
+    } catch (err) {
+      error(`Failed to fetch workspace analytics: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('user')
+  .description('Show your personal analytics')
+  .action(async () => {
+    try {
+      const userId = config.get('userId');
+      const data = await withSpinner('Fetching user analytics...', () =>
+        client.get(`/analytics/user/${userId}`)
+      );
+
+      const a = data.analytics || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Your Analytics'));
+      console.log(chalk.bold('  ──────────────'));
+      console.log(chalk.bold('  Cards Completed: '), a.completedCards ?? 0);
+      console.log(chalk.bold('  Cards Assigned:  '), a.assignedCards ?? 0);
+      console.log(chalk.bold('  Time Tracked:    '), a.timeTracked ? formatDuration(a.timeTracked) : '0s');
+      console.log(chalk.bold('  Active Boards:   '), a.activeBoards ?? 0);
+      console.log();
+    } catch (err) {
+      error(`Failed to fetch user analytics: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('trends')
+  .description('Show analytics trends')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching trends...', () =>
+        client.get('/analytics/trends')
+      );
+
+      const trends = data.trends || data.data || data;
+      const rows = (Array.isArray(trends) ? trends : []).map(t => ({
+        period: t.period || t.date || 'N/A',
+        cards: String(t.cardsCreated ?? 0),
+        completed: String(t.cardsCompleted ?? 0),
+        members: String(t.activeMembers ?? 0),
+      }));
+
+      output(rows, {
+        headers: ['Period', 'Created', 'Completed', 'Active Members'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch trends: ${err.message}`);
+    }
+  });
+
+analytics
+  .command('export <boardId>')
+  .description('Export board analytics')
+  .option('-o, --output <file>', 'Output file path', 'analytics-export.json')
+  .action(async (boardId, options) => {
+    try {
+      const data = await withSpinner('Exporting analytics...', () =>
+        client.get(`/analytics/export/${boardId}`)
+      );
+
+      const fs = require('fs');
+      const exportData = data.export || data.data || data;
+      fs.writeFileSync(options.output, JSON.stringify(exportData, null, 2));
+      success(`Analytics exported to ${chalk.bold(options.output)}`);
+    } catch (err) {
+      error(`Failed to export analytics: ${err.message}`);
+    }
+  });
+
+module.exports = analytics;

package/src/commands/api-key.js

@@ -0,0 +1,140 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const client = require('../lib/client');
+const { output, success, error, warn } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+const { confirmAction } = require('../utils/prompts');
+
+const apiKey = new Command('api-key')
+  .alias('ak')
+  .description('API key management commands (some operations require session auth)');
+
+const AUTH_NOTE = 'Note: API key management may be restricted when authenticated via API key. Use browser session if this fails.';
+
+apiKey
+  .command('list')
+  .alias('ls')
+  .description('List your API keys')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching API keys...', () =>
+        client.get('/api-keys')
+      );
+
+      const keys = data.apiKeys || data.data || data;
+      const rows = (Array.isArray(keys) ? keys : []).map(k => ({
+        name: k.name || 'Unnamed',
+        prefix: k.prefix || k.key?.substring(0, 8) || 'N/A',
+        created: new Date(k.createdAt).toLocaleDateString(),
+        lastUsed: k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleDateString() : 'Never',
+        id: k._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'Prefix', 'Created', 'Last Used', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to list API keys: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('create')
+  .description('Create a new API key')
+  .option('--name <name>', 'Key name (required)')
+  .action(async (options) => {
+    try {
+      if (!options.name) return error('Key name is required. Use --name <name>.');
+
+      const data = await withSpinner('Creating API key...', () =>
+        client.post('/api-keys', { name: options.name })
+      );
+
+      const key = data.apiKey || data.key || data.data || data;
+      console.log();
+      success(`Created API key: ${chalk.bold(options.name)}`);
+      if (key.key || key.token) {
+        console.log();
+        console.log(chalk.yellow('  Save this key — it won\'t be shown again:'));
+        console.log(chalk.bold(`  ${key.key || key.token}`));
+        console.log();
+      }
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to create API key: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('delete <keyId>')
+  .description('Delete an API key')
+  .option('--force', 'Skip confirmation')
+  .action(async (keyId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Delete this API key? Any integrations using it will stop working.');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting API key...', () =>
+        client.delete(`/api-keys/${keyId}`)
+      );
+      success('Deleted API key');
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to delete API key: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('rename <keyId>')
+  .description('Rename an API key')
+  .option('--name <name>', 'New name (required)')
+  .action(async (keyId, options) => {
+    try {
+      if (!options.name) return error('Name is required. Use --name <name>.');
+
+      await withSpinner('Renaming API key...', () =>
+        client.put(`/api-keys/${keyId}`, { name: options.name })
+      );
+      success(`Renamed API key to: ${chalk.bold(options.name)}`);
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to rename API key: ${err.message}`);
+    }
+  });
+
+apiKey
+  .command('regenerate <keyId>')
+  .description('Regenerate an API key')
+  .option('--force', 'Skip confirmation')
+  .action(async (keyId, options) => {
+    try {
+      if (!options.force) {
+        const confirmed = await confirmAction('Regenerate this API key? The old key will stop working immediately.');
+        if (!confirmed) return;
+      }
+
+      const data = await withSpinner('Regenerating API key...', () =>
+        client.post(`/api-keys/${keyId}/regenerate`)
+      );
+
+      const key = data.apiKey || data.key || data.data || data;
+      console.log();
+      success('API key regenerated');
+      if (key.key || key.token) {
+        console.log();
+        console.log(chalk.yellow('  Save this key — it won\'t be shown again:'));
+        console.log(chalk.bold(`  ${key.key || key.token}`));
+        console.log();
+      }
+    } catch (err) {
+      warn(AUTH_NOTE);
+      error(`Failed to regenerate API key: ${err.message}`);
+    }
+  });
+
+module.exports = apiKey;

package/src/commands/auth.js

@@ -245,6 +245,8 @@ auth
   .description('Clear stored credentials')
   .action(() => {
     config.set('apiKey', '');
+    config.set('apiUrl', 'https://api.zoobbe.com');
+    config.set('webUrl', '');
     config.set('userId', '');
     config.set('userName', '');
     config.set('email', '');

package/src/commands/automation.js

@@ -0,0 +1,255 @@
+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 { formatRelativeTime } = require('../utils/format');
+
+const automation = new Command('automation')
+  .alias('auto')
+  .description('Board automation commands');
+
+automation
+  .command('list')
+  .alias('ls')
+  .description('List automations on 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 automations...', () =>
+        client.get(`/boards/${options.board}/automations`)
+      );
+
+      const automations = data.automations || data.data || data;
+      const rows = (Array.isArray(automations) ? automations : []).map(a => ({
+        name: a.name || a.title || 'Unnamed',
+        trigger: a.trigger?.type || a.triggerType || 'N/A',
+        action: a.action?.type || a.actionType || 'N/A',
+        status: a.enabled ? chalk.green('enabled') : chalk.yellow('disabled'),
+        id: a._id,
+      }));
+
+      output(rows, {
+        headers: ['Name', 'Trigger', 'Action', 'Status', 'ID'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list automations: ${err.message}`);
+    }
+  });
+
+automation
+  .command('create')
+  .description('Create a new automation (interactive)')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const inquirer = require('inquirer');
+
+      // Fetch available options
+      const optionsData = await withSpinner('Fetching automation options...', () =>
+        client.get(`/boards/${options.board}/automations/options`)
+      );
+      const opts = optionsData.options || optionsData.data || optionsData;
+
+      const triggers = opts.triggers || ['card_created', 'card_moved', 'card_completed', 'due_date_reached'];
+      const actions = opts.actions || ['move_card', 'assign_member', 'add_label', 'send_notification'];
+
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Automation name:',
+          validate: v => v.length > 0 || 'Name is required',
+        },
+        {
+          type: 'list',
+          name: 'triggerType',
+          message: 'Select trigger:',
+          choices: triggers,
+        },
+        {
+          type: 'list',
+          name: 'actionType',
+          message: 'Select action:',
+          choices: actions,
+        },
+      ]);
+
+      const data = await withSpinner('Creating automation...', () =>
+        client.post(`/boards/${options.board}/automations`, {
+          name: answers.name,
+          trigger: { type: answers.triggerType },
+          action: { type: answers.actionType },
+        })
+      );
+
+      const a = data.automation || data.data || data;
+      success(`Created automation: ${chalk.bold(answers.name)} (${a._id})`);
+    } catch (err) {
+      error(`Failed to create automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('update <automationId>')
+  .description('Update an automation')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('--name <name>', 'New name')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const body = {};
+      if (options.name) body.name = options.name;
+      if (Object.keys(body).length === 0) return error('Provide --name.');
+
+      await withSpinner('Updating automation...', () =>
+        client.put(`/boards/${options.board}/automations/${automationId}`, body)
+      );
+      success(`Updated automation ${automationId}`);
+    } catch (err) {
+      error(`Failed to update automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('delete <automationId>')
+  .description('Delete an automation')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('--force', 'Skip confirmation')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      if (!options.force) {
+        const confirmed = await confirmAction('Delete this automation?');
+        if (!confirmed) return;
+      }
+
+      await withSpinner('Deleting automation...', () =>
+        client.delete(`/boards/${options.board}/automations/${automationId}`)
+      );
+      success('Deleted automation');
+    } catch (err) {
+      error(`Failed to delete automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('toggle <automationId>')
+  .description('Enable or disable an automation')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Toggling automation...', () =>
+        client.patch(`/boards/${options.board}/automations/${automationId}/toggle`)
+      );
+      const a = data.automation || data.data || data;
+      success(a.enabled ? 'Automation enabled' : 'Automation disabled');
+    } catch (err) {
+      error(`Failed to toggle automation: ${err.message}`);
+    }
+  });
+
+automation
+  .command('logs <automationId>')
+  .description('Show automation execution logs')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('--limit <n>', 'Number of logs', '20')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching logs...', () =>
+        client.get(`/boards/${options.board}/automations/${automationId}/logs`)
+      );
+
+      const logs = data.logs || data.data || data;
+      const logArr = Array.isArray(logs) ? logs : [];
+      const limited = logArr.slice(0, parseInt(options.limit));
+
+      const rows = limited.map(l => ({
+        status: l.success ? chalk.green('success') : chalk.red('failed'),
+        trigger: l.trigger || 'N/A',
+        time: formatRelativeTime(l.createdAt || l.executedAt),
+        error: l.error || '-',
+      }));
+
+      output(rows, {
+        headers: ['Status', 'Trigger', 'Time', 'Error'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch logs: ${err.message}`);
+    }
+  });
+
+automation
+  .command('options')
+  .description('Show available automation triggers and actions')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      const data = await withSpinner('Fetching options...', () =>
+        client.get(`/boards/${options.board}/automations/options`)
+      );
+
+      const opts = data.options || data.data || data;
+      console.log();
+      console.log(chalk.bold('  Available Triggers:'));
+      const triggers = opts.triggers || [];
+      triggers.forEach(t => console.log(`    - ${t.type || t}`));
+      console.log();
+      console.log(chalk.bold('  Available Actions:'));
+      const actions = opts.actions || [];
+      actions.forEach(a => console.log(`    - ${a.type || a}`));
+      console.log();
+    } catch (err) {
+      error(`Failed to fetch options: ${err.message}`);
+    }
+  });
+
+automation
+  .command('info <automationId>')
+  .description('Show automation details')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .action(async (automationId, options) => {
+    try {
+      if (!options.board) return error('Board ID is required. Use -b <boardId>.');
+
+      // Fetch all automations and find the one
+      const data = await withSpinner('Fetching automation...', () =>
+        client.get(`/boards/${options.board}/automations`)
+      );
+
+      const automations = data.automations || data.data || data;
+      const match = (Array.isArray(automations) ? automations : []).find(a => a._id === automationId);
+
+      if (!match) return error(`Automation "${automationId}" not found.`);
+
+      console.log();
+      console.log(chalk.bold('  Name:    '), match.name || 'Unnamed');
+      console.log(chalk.bold('  ID:      '), match._id);
+      console.log(chalk.bold('  Trigger: '), match.trigger?.type || 'N/A');
+      console.log(chalk.bold('  Action:  '), match.action?.type || 'N/A');
+      console.log(chalk.bold('  Status:  '), match.enabled ? 'Enabled' : 'Disabled');
+      console.log(chalk.bold('  Runs:    '), match.executionCount ?? 0);
+      console.log();
+    } catch (err) {
+      error(`Failed to get automation info: ${err.message}`);
+    }
+  });
+
+module.exports = automation;