@zoobbe/cli 1.0.0

package/bin/zoobbe

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+'use strict';
+
+require('../src/index.js');

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@zoobbe/cli",
+  "version": "1.0.0",
+  "description": "Zoobbe CLI - Manage boards, cards, and projects from the terminal",
+  "main": "src/index.js",
+  "bin": {
+    "zoobbe": "./bin/zoobbe"
+  },
+  "scripts": {
+    "start": "node bin/zoobbe",
+    "dev": "node bin/zoobbe",
+    "test": "echo \"Tests coming soon\" && exit 0"
+  },
+  "keywords": [
+    "zoobbe",
+    "cli",
+    "project-management",
+    "kanban",
+    "task-management",
+    "boards",
+    "cards",
+    "ai-agent"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Zoobbe",
+    "url": "https://zoobbe.com"
+  },
+  "homepage": "https://zoobbe.com/cli",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zoobbe/zoobbe-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/zoobbe/zoobbe-cli/issues"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "conf": "^10.2.0",
+    "inquirer": "^8.2.6",
+    "open": "^8.4.2",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/ai.js

@@ -0,0 +1,80 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { success, error, info } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+
+const ai = new Command('ask')
+  .description('AI-powered natural language commands')
+  .argument('<prompt...>', 'Natural language command')
+  .option('-p, --provider <provider>', 'AI provider (claude|openai|ollama)', 'claude')
+  .option('--no-confirm', 'Execute without confirmation')
+  .option('-s, --stream', 'Stream the response')
+  .action(async (promptParts, options) => {
+    try {
+      const prompt = promptParts.join(' ');
+      const workspaceId = config.get('activeWorkspace');
+
+      if (!workspaceId) {
+        return error('No active workspace. Run "zoobbe workspace switch <name>".');
+      }
+
+      info(`Processing: "${prompt}"`);
+      console.log();
+
+      const data = await withSpinner('Thinking...', () =>
+        client.post('/agent/query', {
+          message: prompt,
+          workspace: workspaceId,
+          provider: options.provider,
+          stream: false,
+          confirm: options.confirm !== false,
+        })
+      );
+
+      const result = data.data || data;
+
+      // Display the AI response
+      if (result.plan) {
+        console.log();
+        console.log(chalk.bold('  Plan:'));
+        if (Array.isArray(result.plan)) {
+          result.plan.forEach((step, i) => {
+            console.log(`  ${i + 1}. ${step.description || step}`);
+          });
+        } else {
+          console.log(`  ${result.plan}`);
+        }
+        console.log();
+      }
+
+      if (result.response) {
+        console.log(chalk.bold('  Response:'));
+        console.log(`  ${result.response}`);
+        console.log();
+      }
+
+      if (result.actions && result.actions.length > 0) {
+        console.log(chalk.bold('  Actions taken:'));
+        result.actions.forEach(action => {
+          console.log(`  ${chalk.green('✓')} ${action.description || action.type}`);
+        });
+        console.log();
+      }
+
+      if (result.results) {
+        console.log(chalk.bold('  Results:'));
+        console.log(JSON.stringify(result.results, null, 2));
+        console.log();
+      }
+
+      if (!result.plan && !result.response && !result.actions) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (err) {
+      error(`AI command failed: ${err.message}`);
+    }
+  });
+
+module.exports = ai;

package/src/commands/auth.js

@@ -0,0 +1,120 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { success, error, info } = require('../lib/output');
+
+const auth = new Command('auth')
+  .description('Authentication commands');
+
+auth
+  .command('login')
+  .description('Authenticate with Zoobbe')
+  .option('-t, --token <token>', 'API key for direct login')
+  .option('--url <url>', 'Custom API URL (default: https://api.zoobbe.com)')
+  .action(async (options) => {
+    try {
+      if (options.url) {
+        config.set('apiUrl', options.url);
+      }
+
+      let apiKey = options.token;
+
+      if (!apiKey) {
+        // Interactive login — open browser for auth
+        try {
+          const open = require('open');
+          const apiUrl = config.get('apiUrl');
+          const authUrl = `${apiUrl.replace('api.', '')}/cli/auth`;
+          info(`Opening browser for authentication...`);
+          info(`If it doesn't open, visit: ${chalk.underline(authUrl)}`);
+          await open(authUrl);
+        } catch {
+          // open may fail in headless environments
+        }
+
+        const answers = await inquirer.prompt([{
+          type: 'input',
+          name: 'apiKey',
+          message: 'Paste your API key:',
+          validate: v => v.startsWith('zb_live_') ? true : 'Invalid API key format (should start with zb_live_)',
+        }]);
+        apiKey = answers.apiKey;
+      }
+
+      if (!apiKey.startsWith('zb_live_')) {
+        return error('Invalid API key format. Keys start with "zb_live_".');
+      }
+
+      config.set('apiKey', apiKey);
+
+      // Verify the key works
+      const userData = await client.get('/users/me');
+      const user = userData.user || userData.data || userData;
+
+      config.set('userId', user._id || user.id || '');
+      config.set('userName', user.name || user.userName || '');
+      config.set('email', user.email || '');
+
+      success(`Logged in as ${chalk.bold(user.name || user.email)}`);
+    } catch (err) {
+      config.set('apiKey', '');
+      error(`Login failed: ${err.message}`);
+    }
+  });
+
+auth
+  .command('logout')
+  .description('Clear stored credentials')
+  .action(() => {
+    config.set('apiKey', '');
+    config.set('userId', '');
+    config.set('userName', '');
+    config.set('email', '');
+    config.set('activeWorkspace', '');
+    config.set('activeWorkspaceName', '');
+    success('Logged out successfully');
+  });
+
+auth
+  .command('whoami')
+  .description('Show current authenticated user')
+  .action(async () => {
+    try {
+      const apiKey = config.get('apiKey');
+      if (!apiKey) {
+        return error('Not logged in. Run "zoobbe auth login" first.');
+      }
+
+      const userData = await client.get('/users/me');
+      const user = userData.user || userData.data || userData;
+
+      console.log();
+      console.log(chalk.bold('  User:     '), user.name || user.userName || 'N/A');
+      console.log(chalk.bold('  Email:    '), user.email);
+      console.log(chalk.bold('  API URL:  '), config.get('apiUrl'));
+      console.log(chalk.bold('  Workspace:'), config.get('activeWorkspaceName') || 'Not set');
+      console.log();
+    } catch (err) {
+      error(`Failed to fetch user info: ${err.message}`);
+    }
+  });
+
+auth
+  .command('status')
+  .description('Check authentication status')
+  .action(() => {
+    const apiKey = config.get('apiKey');
+    if (apiKey) {
+      success(`Authenticated (key: ${apiKey.substring(0, 16)}...)`);
+      info(`API URL: ${config.get('apiUrl')}`);
+      if (config.get('activeWorkspaceName')) {
+        info(`Workspace: ${config.get('activeWorkspaceName')}`);
+      }
+    } else {
+      error('Not authenticated. Run "zoobbe auth login".');
+    }
+  });
+
+module.exports = auth;

package/src/commands/board.js

@@ -0,0 +1,156 @@
+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 board = new Command('board')
+  .alias('b')
+  .description('Board management commands');
+
+board
+  .command('list')
+  .alias('ls')
+  .description('List boards in the active workspace')
+  .option('-f, --format <format>', 'Output format')
+  .option('-a, --all', 'Include archived boards')
+  .action(async (options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) {
+        return error('No active workspace. Run "zoobbe workspace switch <name>".');
+      }
+
+      const data = await withSpinner('Fetching boards...', () =>
+        client.get(`/boards?workspaceId=${workspaceId}`)
+      );
+
+      let boards = data.data || data;
+      if (!options.all) {
+        boards = boards.filter(b => !b.isArchived);
+      }
+
+      const rows = boards.map(b => ({
+        name: b.name || b.title,
+        id: b.shortId,
+        visibility: b.visibility || 'Private',
+        lists: String(b.actionLists?.length || 0),
+        members: String(b.members?.length || 0),
+        status: b.isArchived ? chalk.yellow('archived') : chalk.green('active'),
+      }));
+
+      output(rows, {
+        headers: ['Name', 'ID', 'Visibility', 'Lists', 'Members', 'Status'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list boards: ${err.message}`);
+    }
+  });
+
+board
+  .command('create <name>')
+  .description('Create a new board')
+  .option('-v, --visibility <type>', 'Visibility (Private|Public|Workspace)', 'Private')
+  .action(async (name, options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) {
+        return error('No active workspace. Run "zoobbe workspace switch <name>".');
+      }
+
+      const data = await withSpinner('Creating board...', () =>
+        client.post('/boards', {
+          name,
+          workspaceId,
+          visibility: options.visibility,
+        })
+      );
+
+      const b = data.data || data;
+      success(`Created board: ${chalk.bold(b.name || name)} (${b.shortId})`);
+    } catch (err) {
+      error(`Failed to create board: ${err.message}`);
+    }
+  });
+
+board
+  .command('open <nameOrId>')
+  .description('Open a board in the browser')
+  .action(async (nameOrId) => {
+    try {
+      const open = require('open');
+      const apiUrl = config.get('apiUrl');
+      const baseUrl = apiUrl.replace('api.', '');
+      const workspaceName = config.get('activeWorkspaceName');
+
+      // Try to find the board to get its shortId
+      const workspaceId = config.get('activeWorkspace');
+      const data = await client.get(`/boards?workspaceId=${workspaceId}`);
+      const boards = data.data || data;
+      const match = boards.find(b =>
+        b.shortId === nameOrId ||
+        (b.name || '').toLowerCase() === nameOrId.toLowerCase()
+      );
+
+      const boardId = match ? match.shortId : nameOrId;
+      const url = `${baseUrl}/board/${boardId}`;
+      await open(url);
+      success(`Opened board in browser`);
+    } catch (err) {
+      error(`Failed to open board: ${err.message}`);
+    }
+  });
+
+board
+  .command('archive <nameOrId>')
+  .description('Archive a board')
+  .action(async (nameOrId) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      const data = await client.get(`/boards?workspaceId=${workspaceId}`);
+      const boards = data.data || data;
+      const match = boards.find(b =>
+        b.shortId === nameOrId ||
+        (b.name || '').toLowerCase() === nameOrId.toLowerCase()
+      );
+
+      if (!match) {
+        return error(`Board "${nameOrId}" not found.`);
+      }
+
+      await withSpinner('Archiving board...', () =>
+        client.post(`/boards/archive/${match.shortId}`)
+      );
+
+      success(`Archived board: ${chalk.bold(match.name)}`);
+    } catch (err) {
+      error(`Failed to archive board: ${err.message}`);
+    }
+  });
+
+board
+  .command('info <nameOrId>')
+  .description('Show board details')
+  .action(async (nameOrId) => {
+    try {
+      const data = await withSpinner('Fetching board...', () =>
+        client.get(`/boards/${nameOrId}`)
+      );
+
+      const b = data.data || data;
+      console.log();
+      console.log(chalk.bold('  Name:       '), b.name);
+      console.log(chalk.bold('  ID:         '), b.shortId);
+      console.log(chalk.bold('  Visibility: '), b.visibility || 'Private');
+      console.log(chalk.bold('  Members:    '), b.members?.length || 0);
+      console.log(chalk.bold('  Lists:      '), b.actionLists?.length || 0);
+      console.log(chalk.bold('  Created:    '), new Date(b.createdAt).toLocaleDateString());
+      console.log();
+    } catch (err) {
+      error(`Failed to get board info: ${err.message}`);
+    }
+  });
+
+module.exports = board;

package/src/commands/card.js

@@ -0,0 +1,228 @@
+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 card = new Command('card')
+  .alias('c')
+  .description('Card management commands');
+
+card
+  .command('list')
+  .alias('ls')
+  .description('List cards')
+  .option('-b, --board <boardId>', 'Board ID to filter by')
+  .option('-l, --list <listId>', 'List ID to filter by')
+  .option('-a, --assignee <user>', 'Filter by assignee (use "me" for yourself)')
+  .option('--due <when>', 'Filter by due date (today|week|overdue)')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      let path;
+
+      if (options.assignee === 'me') {
+        const userName = config.get('userName');
+        path = `/${userName}/cards`;
+      } else if (options.board) {
+        path = `/boards/${options.board}/cards`;
+      } else if (options.list) {
+        path = `/actionLists/${options.list}/cards/`;
+      } else {
+        // Get cards for current user
+        const userName = config.get('userName');
+        if (!userName) {
+          return error('No user context. Run "zoobbe auth login" first.');
+        }
+        path = `/${userName}/cards`;
+      }
+
+      const data = await withSpinner('Fetching cards...', () =>
+        client.get(path)
+      );
+
+      let cards = data.data || data;
+
+      // Apply due date filter
+      if (options.due && Array.isArray(cards)) {
+        const now = new Date();
+        cards = cards.filter(c => {
+          if (!c.dueDate) return false;
+          const due = new Date(c.dueDate);
+          switch (options.due) {
+            case 'today': return due.toDateString() === now.toDateString();
+            case 'week': return due <= new Date(now.getTime() + 7 * 86400000);
+            case 'overdue': return due < now;
+            default: return true;
+          }
+        });
+      }
+
+      const rows = (Array.isArray(cards) ? cards : []).map(c => ({
+        title: (c.title || c.name || '').substring(0, 50),
+        id: c.shortId || c._id,
+        list: c.actionList?.name || c.actionListName || '',
+        due: c.dueDate ? new Date(c.dueDate).toLocaleDateString() : '-',
+        members: String(c.members?.length || 0),
+        priority: c.priority || '-',
+      }));
+
+      output(rows, {
+        headers: ['Title', 'ID', 'List', 'Due', 'Members', 'Priority'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list cards: ${err.message}`);
+    }
+  });
+
+card
+  .command('create <title>')
+  .description('Create a new card')
+  .option('-b, --board <boardId>', 'Board ID (required)')
+  .option('-l, --list <listId>', 'Action list ID (uses first list if not specified)')
+  .option('-d, --description <desc>', 'Card description')
+  .option('--due <date>', 'Due date (YYYY-MM-DD)')
+  .option('--priority <level>', 'Priority (low|medium|high|critical)')
+  .action(async (title, options) => {
+    try {
+      if (!options.board) {
+        return error('Board ID is required. Use -b <boardId>.');
+      }
+
+      let listId = options.list;
+
+      // If no list specified, get the first list from the board
+      if (!listId) {
+        const listsData = await client.get(`/boards/${options.board}/lists`);
+        const lists = listsData.data || listsData;
+        if (!lists || lists.length === 0) {
+          return error('Board has no lists. Create one first.');
+        }
+        listId = lists[0].shortId || lists[0]._id;
+      }
+
+      const body = {
+        title,
+        boardId: options.board,
+        actionListId: listId,
+      };
+
+      if (options.description) body.description = options.description;
+      if (options.due) body.dueDate = options.due;
+      if (options.priority) body.priority = options.priority;
+
+      const data = await withSpinner('Creating card...', () =>
+        client.post('/cards', body)
+      );
+
+      const c = data.data || data;
+      success(`Created card: ${chalk.bold(title)} (${c.shortId || c._id})`);
+    } catch (err) {
+      error(`Failed to create card: ${err.message}`);
+    }
+  });
+
+card
+  .command('move <cardId>')
+  .description('Move a card to a different list')
+  .option('-l, --list <listId>', 'Target list ID (required)')
+  .action(async (cardId, options) => {
+    try {
+      if (!options.list) {
+        return error('Target list ID is required. Use -l <listId>.');
+      }
+
+      await withSpinner('Moving card...', () =>
+        client.post(`/cards/update/${cardId}`, {
+          actionListId: options.list,
+        })
+      );
+
+      success(`Moved card ${cardId} to list ${options.list}`);
+    } catch (err) {
+      error(`Failed to move card: ${err.message}`);
+    }
+  });
+
+card
+  .command('assign <cardId>')
+  .description('Assign a user to a card')
+  .option('-u, --user <userId>', 'User ID to assign (required)')
+  .action(async (cardId, options) => {
+    try {
+      if (!options.user) {
+        return error('User ID is required. Use -u <userId>.');
+      }
+
+      await withSpinner('Assigning card...', () =>
+        client.post(`/cards/${cardId}/addMember`, {
+          memberId: options.user,
+        })
+      );
+
+      success(`Assigned user to card ${cardId}`);
+    } catch (err) {
+      error(`Failed to assign card: ${err.message}`);
+    }
+  });
+
+card
+  .command('comment <cardId> <message>')
+  .description('Add a comment to a card')
+  .action(async (cardId, message) => {
+    try {
+      await withSpinner('Adding comment...', () =>
+        client.post(`/cards/${cardId}/comments`, { text: message })
+      );
+
+      success(`Comment added to card ${cardId}`);
+    } catch (err) {
+      error(`Failed to add comment: ${err.message}`);
+    }
+  });
+
+card
+  .command('done <cardId>')
+  .description('Mark a card as complete')
+  .action(async (cardId) => {
+    try {
+      await withSpinner('Updating card...', () =>
+        client.post(`/cards/update/${cardId}`, { isComplete: true })
+      );
+
+      success(`Card ${cardId} marked as complete`);
+    } catch (err) {
+      error(`Failed to update card: ${err.message}`);
+    }
+  });
+
+card
+  .command('info <cardId>')
+  .description('Show card details')
+  .action(async (cardId) => {
+    try {
+      const data = await withSpinner('Fetching card...', () =>
+        client.get(`/cards/${cardId}`)
+      );
+
+      const c = data.data || data;
+      console.log();
+      console.log(chalk.bold('  Title:      '), c.title || c.name);
+      console.log(chalk.bold('  ID:         '), c.shortId || c._id);
+      console.log(chalk.bold('  List:       '), c.actionList?.name || 'N/A');
+      console.log(chalk.bold('  Members:    '), c.members?.length || 0);
+      console.log(chalk.bold('  Due Date:   '), c.dueDate ? new Date(c.dueDate).toLocaleDateString() : 'None');
+      console.log(chalk.bold('  Priority:   '), c.priority || 'None');
+      console.log(chalk.bold('  Complete:   '), c.isComplete ? 'Yes' : 'No');
+      if (c.description) {
+        console.log(chalk.bold('  Description:'), c.description.substring(0, 100));
+      }
+      console.log();
+    } catch (err) {
+      error(`Failed to get card info: ${err.message}`);
+    }
+  });
+
+module.exports = card;

package/src/commands/config.js

@@ -0,0 +1,57 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const { success, error } = require('../lib/output');
+
+const configCmd = new Command('config')
+  .description('CLI configuration');
+
+configCmd
+  .command('set <key> <value>')
+  .description('Set a config value (apiUrl, format)')
+  .action((key, value) => {
+    const allowedKeys = ['apiUrl', 'format'];
+    if (!allowedKeys.includes(key)) {
+      return error(`Invalid config key. Allowed: ${allowedKeys.join(', ')}`);
+    }
+    config.set(key, value);
+    success(`Set ${key} = ${value}`);
+  });
+
+configCmd
+  .command('get <key>')
+  .description('Get a config value')
+  .action((key) => {
+    const value = config.get(key);
+    if (value !== undefined && value !== '') {
+      console.log(value);
+    } else {
+      error(`Config key "${key}" not set`);
+    }
+  });
+
+configCmd
+  .command('list')
+  .alias('ls')
+  .description('Show all config values')
+  .action(() => {
+    const store = config.store;
+    console.log();
+    Object.entries(store).forEach(([key, value]) => {
+      // Mask API key
+      const displayValue = key === 'apiKey' && value
+        ? `${value.substring(0, 16)}...`
+        : value;
+      console.log(`  ${chalk.bold(key)}: ${displayValue || chalk.dim('(not set)')}`);
+    });
+    console.log();
+  });
+
+configCmd
+  .command('path')
+  .description('Show config file location')
+  .action(() => {
+    console.log(config.path);
+  });
+
+module.exports = configCmd;

package/src/commands/page.js

@@ -0,0 +1,102 @@
+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 page = new Command('page')
+  .alias('p')
+  .description('Page management commands');
+
+page
+  .command('list')
+  .alias('ls')
+  .description('List pages in the active workspace')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+
+      const data = await withSpinner('Fetching pages...', () =>
+        client.get(`/pages/all${workspaceId ? `?workspaceId=${workspaceId}` : ''}`)
+      );
+
+      const pages = data.data || data;
+      const rows = (Array.isArray(pages) ? pages : []).map(p => ({
+        title: (p.title || 'Untitled').substring(0, 50),
+        id: p.shortId || p._id,
+        visibility: p.visibility || 'Private',
+        updated: new Date(p.updatedAt || p.createdAt).toLocaleDateString(),
+      }));
+
+      output(rows, {
+        headers: ['Title', 'ID', 'Visibility', 'Updated'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list pages: ${err.message}`);
+    }
+  });
+
+page
+  .command('create <title>')
+  .description('Create a new page')
+  .option('--workspace <id>', 'Workspace ID (uses active workspace)')
+  .action(async (title, options) => {
+    try {
+      const workspaceId = options.workspace || config.get('activeWorkspace');
+      if (!workspaceId) {
+        return error('No workspace specified. Use --workspace or set an active workspace.');
+      }
+
+      const data = await withSpinner('Creating page...', () =>
+        client.post('/pages', { title, workspaceId })
+      );
+
+      const p = data.data || data;
+      success(`Created page: ${chalk.bold(title)} (${p.shortId || p._id})`);
+    } catch (err) {
+      error(`Failed to create page: ${err.message}`);
+    }
+  });
+
+page
+  .command('open <pageId>')
+  .description('Open a page in the browser')
+  .action(async (pageId) => {
+    try {
+      const open = require('open');
+      const apiUrl = config.get('apiUrl');
+      const baseUrl = apiUrl.replace('api.', '');
+      await open(`${baseUrl}/page/${pageId}`);
+      success('Opened page in browser');
+    } catch (err) {
+      error(`Failed to open page: ${err.message}`);
+    }
+  });
+
+page
+  .command('info <pageId>')
+  .description('Show page details')
+  .action(async (pageId) => {
+    try {
+      const data = await withSpinner('Fetching page...', () =>
+        client.get(`/pages/${pageId}`)
+      );
+
+      const p = data.data || data;
+      console.log();
+      console.log(chalk.bold('  Title:      '), p.title || 'Untitled');
+      console.log(chalk.bold('  ID:         '), p.shortId || p._id);
+      console.log(chalk.bold('  Visibility: '), p.visibility || 'Private');
+      console.log(chalk.bold('  Members:    '), p.members?.length || 0);
+      console.log(chalk.bold('  Created:    '), new Date(p.createdAt).toLocaleDateString());
+      console.log(chalk.bold('  Updated:    '), new Date(p.updatedAt).toLocaleDateString());
+      console.log();
+    } catch (err) {
+      error(`Failed to get page info: ${err.message}`);
+    }
+  });
+
+module.exports = page;

package/src/commands/search.js

@@ -0,0 +1,48 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { output, error } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+
+const search = new Command('search')
+  .alias('s')
+  .description('Search across boards, cards, and pages')
+  .argument('<query>', 'Search query')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (query, options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+
+      const data = await withSpinner(`Searching for "${query}"...`, () =>
+        client.post('/global/search', {
+          query,
+          workspaceId,
+        })
+      );
+
+      const results = data.data || data;
+
+      if (!results || (Array.isArray(results) && results.length === 0)) {
+        console.log(chalk.yellow('  No results found.'));
+        return;
+      }
+
+      // Format results based on type
+      const rows = (Array.isArray(results) ? results : [results]).map(r => ({
+        type: r.type || 'item',
+        title: (r.title || r.name || '').substring(0, 50),
+        id: r.shortId || r._id || '',
+        context: r.boardName || r.workspaceName || '',
+      }));
+
+      output(rows, {
+        headers: ['Type', 'Title', 'ID', 'Context'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Search failed: ${err.message}`);
+    }
+  });
+
+module.exports = search;

package/src/commands/status.js

@@ -0,0 +1,67 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { output, error, info } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+
+const status = new Command('status')
+  .description('Show your cards across all boards')
+  .option('-f, --format <format>', 'Output format')
+  .option('--due', 'Only show cards with due dates')
+  .option('--overdue', 'Only show overdue cards')
+  .action(async (options) => {
+    try {
+      const userName = config.get('userName');
+      if (!userName) {
+        return error('Not logged in. Run "zoobbe auth login" first.');
+      }
+
+      const data = await withSpinner('Fetching your cards...', () =>
+        client.get(`/${userName}/cards`)
+      );
+
+      let cards = data.data || data;
+      const now = new Date();
+
+      if (options.overdue) {
+        cards = cards.filter(c => c.dueDate && new Date(c.dueDate) < now);
+      } else if (options.due) {
+        cards = cards.filter(c => c.dueDate);
+      }
+
+      if (!cards || cards.length === 0) {
+        info('No cards assigned to you.');
+        return;
+      }
+
+      console.log();
+      console.log(chalk.bold(`  Your cards (${cards.length}):`));
+      console.log();
+
+      const rows = cards.map(c => {
+        let dueStr = '-';
+        if (c.dueDate) {
+          const due = new Date(c.dueDate);
+          dueStr = due < now ? chalk.red(due.toLocaleDateString()) : chalk.green(due.toLocaleDateString());
+        }
+
+        return {
+          title: (c.title || c.name || '').substring(0, 40),
+          id: c.shortId || '',
+          board: c.boardName || c.board?.name || '',
+          list: c.actionList?.name || '',
+          due: dueStr,
+        };
+      });
+
+      output(rows, {
+        headers: ['Title', 'ID', 'Board', 'List', 'Due'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to fetch status: ${err.message}`);
+    }
+  });
+
+module.exports = status;

package/src/commands/workspace.js

@@ -0,0 +1,147 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const config = require('../lib/config');
+const client = require('../lib/client');
+const { output, success, error, info } = require('../lib/output');
+const { withSpinner } = require('../utils/spinner');
+
+const workspace = new Command('workspace')
+  .alias('ws')
+  .description('Workspace management commands');
+
+workspace
+  .command('list')
+  .alias('ls')
+  .description('List your workspaces')
+  .option('-f, --format <format>', 'Output format (table|json|plain)')
+  .action(async (options) => {
+    try {
+      const data = await withSpinner('Fetching workspaces...', () =>
+        client.get('/workspaces/me')
+      );
+
+      const workspaces = data.data || data;
+      const active = config.get('activeWorkspace');
+
+      const rows = workspaces.map(ws => ({
+        name: ws.name + (ws.shortId === active ? chalk.green(' (active)') : ''),
+        id: ws.shortId,
+        members: String(ws.members?.length || 0),
+        boards: String(ws.boards?.length || 0),
+        role: ws.members?.find(m => m.user === config.get('userId'))?.role || 'member',
+      }));
+
+      output(rows, {
+        headers: ['Name', 'ID', 'Members', 'Boards', 'Role'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list workspaces: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('switch <nameOrId>')
+  .description('Set the active workspace')
+  .action(async (nameOrId) => {
+    try {
+      const data = await withSpinner('Fetching workspaces...', () =>
+        client.get('/workspaces/me')
+      );
+
+      const workspaces = data.data || data;
+      const match = workspaces.find(ws =>
+        ws.shortId === nameOrId ||
+        ws.name.toLowerCase() === nameOrId.toLowerCase() ||
+        ws.shortName?.toLowerCase() === nameOrId.toLowerCase()
+      );
+
+      if (!match) {
+        return error(`Workspace "${nameOrId}" not found. Run "zoobbe workspace list" to see available workspaces.`);
+      }
+
+      config.set('activeWorkspace', match.shortId);
+      config.set('activeWorkspaceName', match.name);
+      success(`Switched to workspace: ${chalk.bold(match.name)}`);
+    } catch (err) {
+      error(`Failed to switch workspace: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('create <name>')
+  .description('Create a new workspace')
+  .action(async (name) => {
+    try {
+      const data = await withSpinner('Creating workspace...', () =>
+        client.post('/workspaces/me', { name })
+      );
+
+      const ws = data.data || data;
+      success(`Created workspace: ${chalk.bold(ws.name)} (${ws.shortId})`);
+    } catch (err) {
+      error(`Failed to create workspace: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('members')
+  .description('List members of the active workspace')
+  .option('-f, --format <format>', 'Output format')
+  .action(async (options) => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) {
+        return error('No active workspace. Run "zoobbe workspace switch <name>".');
+      }
+
+      const data = await withSpinner('Fetching members...', () =>
+        client.get(`/members/workspace/${workspaceId}`)
+      );
+
+      const members = data.data || data;
+      const rows = members.map(m => {
+        const user = m.user || m;
+        return {
+          name: user.userName || user.username || 'N/A',
+          email: user.email || 'N/A',
+          role: m.role || 'member',
+        };
+      });
+
+      output(rows, {
+        headers: ['Name', 'Email', 'Role'],
+        format: options.format,
+      });
+    } catch (err) {
+      error(`Failed to list members: ${err.message}`);
+    }
+  });
+
+workspace
+  .command('info')
+  .description('Show active workspace details')
+  .action(async () => {
+    try {
+      const workspaceId = config.get('activeWorkspace');
+      if (!workspaceId) {
+        return error('No active workspace. Run "zoobbe workspace switch <name>".');
+      }
+
+      const data = await withSpinner('Fetching workspace info...', () =>
+        client.get(`/workspaces/${workspaceId}`)
+      );
+
+      const ws = data.data || data;
+      console.log();
+      console.log(chalk.bold('  Name:    '), ws.name);
+      console.log(chalk.bold('  ID:      '), ws.shortId);
+      console.log(chalk.bold('  Members: '), ws.members?.length || 0);
+      console.log(chalk.bold('  Boards:  '), ws.boards?.length || 0);
+      console.log();
+    } catch (err) {
+      error(`Failed to get workspace info: ${err.message}`);
+    }
+  });
+
+module.exports = workspace;

package/src/index.js

@@ -0,0 +1,55 @@
+const { Command } = require('commander');
+const chalk = require('chalk');
+const pkg = require('../package.json');
+
+const program = new Command();
+
+program
+  .name('zoobbe')
+  .description('Zoobbe CLI — Manage boards, cards, and projects from the terminal')
+  .version(pkg.version)
+  .option('-f, --format <format>', 'Output format (table|json|plain)')
+  .option('--workspace <id>', 'Override active workspace');
+
+// Register commands
+program.addCommand(require('./commands/auth'));
+program.addCommand(require('./commands/workspace'));
+program.addCommand(require('./commands/board'));
+program.addCommand(require('./commands/card'));
+program.addCommand(require('./commands/page'));
+program.addCommand(require('./commands/search'));
+program.addCommand(require('./commands/ai'));
+program.addCommand(require('./commands/status'));
+program.addCommand(require('./commands/config'));
+
+// Global option handling
+program.hook('preAction', (thisCommand) => {
+  const config = require('./lib/config');
+  const opts = program.opts();
+
+  if (opts.format) {
+    config.set('format', opts.format);
+  }
+  if (opts.workspace) {
+    config.set('activeWorkspace', opts.workspace);
+  }
+});
+
+// Default action (no command)
+program.action(() => {
+  console.log();
+  console.log(chalk.bold('  Zoobbe CLI') + ` v${pkg.version}`);
+  console.log();
+  console.log('  Quick start:');
+  console.log(`    ${chalk.cyan('zoobbe auth login')}          Authenticate with Zoobbe`);
+  console.log(`    ${chalk.cyan('zoobbe workspace list')}      List your workspaces`);
+  console.log(`    ${chalk.cyan('zoobbe workspace switch')}    Set active workspace`);
+  console.log(`    ${chalk.cyan('zoobbe board list')}          List boards`);
+  console.log(`    ${chalk.cyan('zoobbe card list')}           List your cards`);
+  console.log(`    ${chalk.cyan('zoobbe ask "..."')}           AI-powered commands`);
+  console.log();
+  console.log(`  Run ${chalk.cyan('zoobbe --help')} for all commands.`);
+  console.log();
+});
+
+program.parse(process.argv);

package/src/lib/client.js

@@ -0,0 +1,74 @@
+const config = require('./config');
+
+class ZoobbeClient {
+  get baseUrl() {
+    return config.get('apiUrl');
+  }
+
+  get apiKey() {
+    return config.get('apiKey');
+  }
+
+  get headers() {
+    return {
+      'Authorization': `Bearer ${this.apiKey}`,
+      'Content-Type': 'application/json',
+      'User-Agent': 'Zoobbe-CLI/1.0',
+    };
+  }
+
+  ensureAuth() {
+    if (!this.apiKey) {
+      throw new Error('Not authenticated. Run "zoobbe login" first.');
+    }
+  }
+
+  async request(method, path, body = null) {
+    this.ensureAuth();
+
+    const url = `${this.baseUrl}/v1${path}`;
+    const options = {
+      method,
+      headers: this.headers,
+    };
+
+    if (body && method !== 'GET') {
+      options.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, options);
+    const data = await response.json();
+
+    if (!response.ok) {
+      const msg = data.error || data.message || `Request failed with status ${response.status}`;
+      const error = new Error(msg);
+      error.status = response.status;
+      error.data = data;
+      throw error;
+    }
+
+    return data;
+  }
+
+  async get(path) {
+    return this.request('GET', path);
+  }
+
+  async post(path, body) {
+    return this.request('POST', path, body);
+  }
+
+  async put(path, body) {
+    return this.request('PUT', path, body);
+  }
+
+  async patch(path, body) {
+    return this.request('PATCH', path, body);
+  }
+
+  async delete(path) {
+    return this.request('DELETE', path);
+  }
+}
+
+module.exports = new ZoobbeClient();

package/src/lib/config.js

@@ -0,0 +1,20 @@
+const Conf = require('conf');
+const path = require('path');
+const os = require('os');
+
+const config = new Conf({
+  projectName: 'zoobbe',
+  cwd: path.join(os.homedir(), '.zoobbe'),
+  schema: {
+    apiKey: { type: 'string', default: '' },
+    apiUrl: { type: 'string', default: 'https://api.zoobbe.com' },
+    activeWorkspace: { type: 'string', default: '' },
+    activeWorkspaceName: { type: 'string', default: '' },
+    format: { type: 'string', enum: ['table', 'json', 'plain'], default: 'table' },
+    userId: { type: 'string', default: '' },
+    userName: { type: 'string', default: '' },
+    email: { type: 'string', default: '' },
+  },
+});
+
+module.exports = config;

package/src/lib/output.js

@@ -0,0 +1,74 @@
+const chalk = require('chalk');
+const Table = require('cli-table3');
+const config = require('./config');
+
+/**
+ * Output data in the configured format (table, json, or plain).
+ */
+function output(data, options = {}) {
+  const format = options.format || config.get('format') || 'table';
+
+  switch (format) {
+    case 'json':
+      console.log(JSON.stringify(data, null, 2));
+      break;
+    case 'plain':
+      if (Array.isArray(data)) {
+        data.forEach(item => {
+          const values = Object.values(item);
+          console.log(values.join('\t'));
+        });
+      } else {
+        console.log(Object.values(data).join('\t'));
+      }
+      break;
+    case 'table':
+    default:
+      if (options.headers && Array.isArray(data)) {
+        printTable(options.headers, data);
+      } else if (Array.isArray(data)) {
+        data.forEach(item => console.log(item));
+      } else {
+        console.log(data);
+      }
+      break;
+  }
+}
+
+function printTable(headers, rows) {
+  const table = new Table({
+    head: headers.map(h => chalk.cyan.bold(h)),
+    style: { head: [], border: [] },
+  });
+
+  rows.forEach(row => {
+    if (Array.isArray(row)) {
+      table.push(row);
+    } else {
+      table.push(headers.map(h => {
+        const key = h.toLowerCase().replace(/\s+/g, '');
+        return row[key] || row[h] || '';
+      }));
+    }
+  });
+
+  console.log(table.toString());
+}
+
+function success(message) {
+  console.log(chalk.green('✓'), message);
+}
+
+function error(message) {
+  console.error(chalk.red('✗'), message);
+}
+
+function warn(message) {
+  console.log(chalk.yellow('!'), message);
+}
+
+function info(message) {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+module.exports = { output, printTable, success, error, warn, info };

package/src/utils/spinner.js

@@ -0,0 +1,24 @@
+const ora = require('ora');
+
+function createSpinner(text) {
+  return ora({ text, spinner: 'dots' });
+}
+
+/**
+ * Execute an async function with a spinner.
+ */
+async function withSpinner(text, fn) {
+  const spinner = createSpinner(text);
+  spinner.start();
+
+  try {
+    const result = await fn(spinner);
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail(error.message);
+    throw error;
+  }
+}
+
+module.exports = { createSpinner, withSpinner };