kanon-cli 0.1.0

package/src/commands/card.js

@@ -0,0 +1,260 @@
+import chalk from 'chalk';
+import api from '../lib/api.js';
+import { getToken, loadProjectConfig } from '../lib/config.js';
+
+function requireAuth() {
+  if (!getToken()) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+}
+
+async function getBoardContext() {
+  const config = loadProjectConfig();
+  const boardId = config?.board_id;
+  if (!boardId) throw new Error('No board configured. Run: kanon init');
+  const data = await api.getBoard(boardId, { cardLimit: 0 });
+  return data.board || data;
+}
+
+function resolveLabel(board, name) {
+  const lower = name.toLowerCase();
+  const label = (board.labels || []).find(l => l.name.toLowerCase() === lower);
+  if (!label) {
+    const available = (board.labels || []).map(l => l.name).join(', ');
+    throw new Error(`Label "${name}" not found. Available: ${available}`);
+  }
+  return label;
+}
+
+function resolveList(board, name) {
+  const lower = name.toLowerCase();
+  const list = (board.lists || []).find(l => l.title.toLowerCase() === lower);
+  if (!list) {
+    const available = (board.lists || []).map(l => l.title).join(', ');
+    throw new Error(`List "${name}" not found. Available: ${available}`);
+  }
+  return list;
+}
+
+function resolveMember(board, name) {
+  const lower = name.toLowerCase();
+  const member = (board.members || []).find(m =>
+    (m.name || '').toLowerCase().includes(lower) ||
+    (m.email || '').toLowerCase().includes(lower)
+  );
+  if (!member) {
+    const available = (board.members || []).map(m => m.name || m.email).join(', ');
+    throw new Error(`Member "${name}" not found. Available: ${available}`);
+  }
+  return member;
+}
+
+// --- kanon card <id> ---
+
+export async function showCardCommand(cardId) {
+  requireAuth();
+  try {
+    const data = await api.getCard(cardId);
+    const card = data.card || data;
+
+    console.log(chalk.bold(`\n${card.title}`));
+    console.log(chalk.dim(`ID: ${card.id}`));
+    if (card.is_done) console.log(chalk.green('Done'));
+    if (card.due_date) console.log(chalk.yellow(`Due: ${card.due_date.substring(0, 10)}`));
+    if (card.description) console.log(`\n${card.description}`);
+
+    if (card.labels?.length) {
+      console.log(chalk.dim('\nLabels:'));
+      for (const l of card.labels) console.log(`  ${chalk.hex(l.color || '#888')(l.name)}`);
+    }
+
+    if (card.assignees?.length) {
+      console.log(chalk.dim('\nAssignees:'));
+      for (const a of card.assignees) console.log(`  ${a.name || a.email}`);
+    }
+
+    if (card.checklists?.length) {
+      for (const cl of card.checklists) {
+        console.log(chalk.dim(`\nChecklist: ${cl.title}`));
+        for (const item of cl.items || []) {
+          console.log(`  ${item.completed ? chalk.green('[x]') : '[ ]'} ${item.text}`);
+        }
+      }
+    }
+
+    if (card.attachments?.length) {
+      console.log(chalk.dim(`\nAttachments (${card.attachments.length}):`));
+      for (const a of card.attachments) console.log(`  ${a.filename || a.name}`);
+    }
+
+    if (card.comments?.length) {
+      console.log(chalk.dim(`\nComments (${card.comments.length}):`));
+      for (const c of card.comments.slice(0, 15)) {
+        const author = c.user_name || c.user?.name || 'Unknown';
+        console.log(`  ${chalk.cyan(author)} ${chalk.dim(c.created_at)}:`);
+        console.log(`  ${c.text}\n`);
+      }
+    }
+  } catch (err) {
+    console.error(chalk.red(`Failed to read card: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon card create ---
+
+export async function createCardCommand(title, listName, options) {
+  requireAuth();
+  try {
+    const board = await getBoardContext();
+    const list = resolveList(board, listName);
+
+    const data = { title };
+    if (options.description) data.description = options.description;
+    if (options.due) data.due_date = options.due;
+
+    const result = await api.createCard(list.id, data);
+    const cardId = result.card?.id || result.id;
+
+    // Apply labels after creation
+    if (options.label?.length) {
+      for (const name of options.label) {
+        const label = resolveLabel(board, name);
+        await api.addLabel(cardId, label.id);
+      }
+    }
+
+    // Apply assignees after creation
+    if (options.assign?.length) {
+      for (const name of options.assign) {
+        const member = resolveMember(board, name);
+        await api.addAssignee(cardId, member.user_id || member.id);
+      }
+    }
+
+    console.log(chalk.green(`Card created: "${title}" in "${list.title}" (${cardId})`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to create card: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon card update ---
+
+export async function updateCardCommand(cardId, options) {
+  requireAuth();
+  try {
+    // 1. Simple PUT fields
+    const updates = {};
+    if (options.title) updates.title = options.title;
+    if (options.description) updates.description = options.description;
+    if (options.due) updates.due_date = options.due;
+    if (options.clearDue) updates.due_date = null;
+    if (options.done) updates.is_done = true;
+    if (options.undone) updates.is_done = false;
+
+    if (Object.keys(updates).length) {
+      await api.updateCard(cardId, updates);
+    }
+
+    // 2. Labels (need board context)
+    const needsBoard = options.addLabel?.length || options.removeLabel?.length ||
+                       options.move || options.assign?.length || options.unassign?.length;
+    let board;
+    if (needsBoard) {
+      board = await getBoardContext();
+    }
+
+    if (options.addLabel?.length) {
+      for (const name of options.addLabel) {
+        const label = resolveLabel(board, name);
+        await api.addLabel(cardId, label.id);
+      }
+    }
+
+    if (options.removeLabel?.length) {
+      for (const name of options.removeLabel) {
+        const label = resolveLabel(board, name);
+        await api.removeLabel(cardId, label.id);
+      }
+    }
+
+    // 3. Assignees
+    if (options.assign?.length) {
+      for (const name of options.assign) {
+        const member = resolveMember(board, name);
+        await api.addAssignee(cardId, member.user_id || member.id);
+      }
+    }
+
+    if (options.unassign?.length) {
+      for (const name of options.unassign) {
+        const member = resolveMember(board, name);
+        await api.removeAssignee(cardId, member.user_id || member.id);
+      }
+    }
+
+    // 4. Move
+    if (options.move) {
+      const list = resolveList(board, options.move);
+      await api.moveCard(cardId, list.id);
+    }
+
+    // 5. Comment
+    if (options.comment) {
+      await api.addComment(cardId, options.comment);
+    }
+
+    console.log(chalk.green(`Card ${cardId} updated.`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to update card: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon card archive ---
+
+export async function archiveCardCommand(cardId) {
+  requireAuth();
+  try {
+    await api.archiveCard(cardId);
+    console.log(chalk.green(`Card ${cardId} archived.`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to archive card: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon board (kept here as it's board-context) ---
+
+export async function boardCommand() {
+  requireAuth();
+  try {
+    const board = await getBoardContext();
+
+    console.log(chalk.bold(`\n${board.title}`));
+    console.log(chalk.dim(`ID: ${board.id}`));
+
+    if (board.lists?.length) {
+      console.log(chalk.dim('\nLists:'));
+      for (const l of board.lists) {
+        const cardCount = l.cards?.length || 0;
+        console.log(`  ${l.title} ${chalk.dim(`(${cardCount} cards)`)}`);
+      }
+    }
+
+    if (board.labels?.length) {
+      console.log(chalk.dim('\nLabels:'));
+      for (const l of board.labels) console.log(`  ${chalk.hex(l.color || '#888')(l.name)}`);
+    }
+
+    if (board.members?.length) {
+      console.log(chalk.dim('\nMembers:'));
+      for (const m of board.members) console.log(`  ${m.name || m.email}`);
+    }
+  } catch (err) {
+    console.error(chalk.red(`Failed to read board: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/cards.js

@@ -0,0 +1,79 @@
+import chalk from 'chalk';
+import api from '../lib/api.js';
+import { getToken, loadProjectConfig } from '../lib/config.js';
+
+function requireAuth() {
+  if (!getToken()) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+}
+
+export async function cardsCommand(options) {
+  requireAuth();
+
+  const config = loadProjectConfig();
+  if (!config?.board_id) {
+    console.error(chalk.red('No board configured. Run: kanon init'));
+    process.exit(1);
+  }
+
+  try {
+    const data = await api.getBoard(config.board_id, { cardLimit: 50 });
+    const lists = data.board?.lists || [];
+
+    if (!lists.length) {
+      console.log(chalk.yellow('No lists found on this board.'));
+      return;
+    }
+
+    let totalCards = 0;
+
+    for (const list of lists) {
+      let cards = list.cards || [];
+
+      // Filter by list name
+      if (options.list) {
+        if (!list.title?.toLowerCase().includes(options.list.toLowerCase())) continue;
+      }
+
+      // Filter by label
+      if (options.label) {
+        cards = cards.filter(c =>
+          c.labels?.some(l => l.name?.toLowerCase().includes(options.label.toLowerCase()))
+        );
+      }
+
+      // Filter by assignee (mine)
+      if (options.mine) {
+        const { getUserId } = await import('../lib/config.js');
+        const myId = getUserId();
+        cards = cards.filter(c =>
+          c.assignees?.some(a => a.id === myId || a.user_id === myId)
+        );
+      }
+
+      if (!cards.length && !options.all) continue;
+
+      console.log(chalk.bold(`\n${list.title} (${cards.length})`));
+
+      for (const card of cards) {
+        const labels = card.labels?.map(l => chalk.hex(l.color || '#888')(l.name)).join(' ') || '';
+        const assignees = card.assignees?.map(a => a.name || a.user_name).join(', ') || '';
+        const due = card.due_date ? chalk.yellow(` due:${card.due_date.substring(0, 10)}`) : '';
+        const done = card.is_done ? chalk.green(' done') : '';
+
+        console.log(`  ${chalk.white(card.title)}${done}${due} ${chalk.dim(card.id)}`);
+        if (labels) console.log(`    ${labels}`);
+        if (assignees) console.log(`    ${chalk.dim(assignees)}`);
+
+        totalCards++;
+      }
+    }
+
+    console.log(chalk.dim(`\n${totalCards} card(s) shown.\n`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to fetch cards: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/checklist.js

@@ -0,0 +1,129 @@
+import chalk from 'chalk';
+import api from '../lib/api.js';
+import { getToken } from '../lib/config.js';
+
+function requireAuth() {
+  if (!getToken()) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+}
+
+async function getCardChecklists(cardId) {
+  const data = await api.getCard(cardId);
+  const card = data.card || data;
+  return card.checklists || [];
+}
+
+function findItem(checklists, text) {
+  const lower = text.toLowerCase();
+  for (const cl of checklists) {
+    for (const item of cl.items || []) {
+      if (item.text.toLowerCase().includes(lower)) {
+        return item;
+      }
+    }
+  }
+  return null;
+}
+
+// --- kanon checklist <cardId> create "title" ---
+
+export async function checklistCreateCommand(cardId, title) {
+  requireAuth();
+  try {
+    const result = await api.createChecklist(cardId, title);
+    const id = result.checklist?.id || result.id;
+    console.log(chalk.green(`Checklist "${title}" created on card ${cardId} (${id}).`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to create checklist: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon checklist <cardId> add "item text" ---
+
+export async function checklistAddCommand(cardId, text) {
+  requireAuth();
+  try {
+    let checklists = await getCardChecklists(cardId);
+    let checklistId;
+
+    if (checklists.length === 0) {
+      // Create a default checklist, then re-fetch to get its ID
+      await api.createChecklist(cardId, 'Checklist');
+      checklists = await getCardChecklists(cardId);
+      checklistId = checklists[0]?.id;
+      if (!checklistId) throw new Error('Failed to create checklist');
+    } else {
+      checklistId = checklists[0].id;
+    }
+
+    await api.addChecklistItem(checklistId, text);
+    console.log(chalk.green(`Item added to checklist on card ${cardId}.`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to add checklist item: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon checklist <cardId> check "item text" ---
+
+export async function checklistCheckCommand(cardId, text) {
+  requireAuth();
+  try {
+    const checklists = await getCardChecklists(cardId);
+    const item = findItem(checklists, text);
+    if (!item) {
+      console.error(chalk.red(`No checklist item matching "${text}" found.`));
+      process.exit(1);
+    }
+    if (!item.completed) {
+      await api.toggleChecklistItem(item.id);
+    }
+    console.log(chalk.green(`Checked: "${item.text}"`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to check item: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon checklist <cardId> uncheck "item text" ---
+
+export async function checklistUncheckCommand(cardId, text) {
+  requireAuth();
+  try {
+    const checklists = await getCardChecklists(cardId);
+    const item = findItem(checklists, text);
+    if (!item) {
+      console.error(chalk.red(`No checklist item matching "${text}" found.`));
+      process.exit(1);
+    }
+    if (item.completed) {
+      await api.toggleChecklistItem(item.id);
+    }
+    console.log(chalk.green(`Unchecked: "${item.text}"`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to uncheck item: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon checklist <cardId> remove "item text" ---
+
+export async function checklistRemoveCommand(cardId, text) {
+  requireAuth();
+  try {
+    const checklists = await getCardChecklists(cardId);
+    const item = findItem(checklists, text);
+    if (!item) {
+      console.error(chalk.red(`No checklist item matching "${text}" found.`));
+      process.exit(1);
+    }
+    await api.deleteChecklistItem(item.id);
+    console.log(chalk.green(`Removed: "${item.text}"`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to remove item: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/dashboard.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { createDashboardServer } from '../dashboard/server/index.js';
+import { exec } from 'child_process';
+import { platform } from 'os';
+
+export async function dashboardCommand(options) {
+  const port = parseInt(options.port) || 3737;
+
+  console.log(chalk.bold('\nKanon Dashboard\n'));
+
+  createDashboardServer(port);
+
+  const url = `http://localhost:${port}`;
+
+  // Open browser (Commander's --no-browser sets options.browser = false)
+  if (options.browser !== false) {
+    const cmd = platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open';
+    exec(`${cmd} ${url}`, () => {});
+    console.log(chalk.dim(`Opening ${url} in browser...`));
+  }
+
+  console.log(chalk.green(`\nDashboard ready at ${chalk.bold(url)}`));
+  console.log(chalk.dim('Press Ctrl+C to stop.\n'));
+}

package/src/commands/init.js

@@ -0,0 +1,89 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import api from '../lib/api.js';
+import { getToken, loadProjectConfig, saveProjectConfig } from '../lib/config.js';
+
+export async function initCommand() {
+  if (!getToken()) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+
+  const existing = loadProjectConfig();
+  if (existing) {
+    console.log(chalk.yellow('kanon.config.yaml already exists in this directory.'));
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(r => rl.question('Overwrite? (y/N) ', r));
+    rl.close();
+    if (answer.toLowerCase() !== 'y') {
+      console.log('Aborted.');
+      return;
+    }
+  }
+
+  try {
+    console.log(chalk.dim('Fetching boards...\n'));
+    const data = await api.getTeams();
+    const teams = data.teams || data;
+
+    // Flatten all boards
+    const allBoards = [];
+    for (const team of teams) {
+      for (const board of team.boards || []) {
+        allBoards.push({ team: team.name, ...board });
+      }
+    }
+
+    if (!allBoards.length) {
+      console.log(chalk.red('No boards found.'));
+      return;
+    }
+
+    console.log(chalk.bold('Select a board:\n'));
+    allBoards.forEach((b, i) => {
+      console.log(`  ${chalk.cyan(i + 1)}  ${b.title || b.name}  ${chalk.dim(`(${b.team})`)}`);
+    });
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const choice = await new Promise(r => rl.question('\nBoard number: ', r));
+    rl.close();
+
+    const idx = parseInt(choice, 10) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= allBoards.length) {
+      console.error(chalk.red('Invalid selection.'));
+      process.exit(1);
+    }
+
+    const board = allBoards[idx];
+
+    const config = {
+      board_id: board.id,
+      watch: {
+        cooldown_seconds: 30,
+        ignore_own_events: true,
+      },
+      rules: {
+        labels: [],
+        events: { agent_assigned: { enabled: true } },
+      },
+      claude: {
+        command: 'claude',
+        max_concurrent: 1,
+      },
+      admin: {
+        check_interval_seconds: 60,
+        max_session_minutes: 30,
+        stuck_timeout_minutes: 5,
+        auto_restart_stuck: true,
+        queue_max_size: 20,
+      },
+    };
+
+    saveProjectConfig(config);
+    console.log(chalk.green(`\nCreated kanon.config.yaml for board "${board.title || board.name}"`));
+    console.log(chalk.dim('Run: kanon watch --dry-run  to test'));
+  } catch (err) {
+    console.error(chalk.red(`Init failed: ${err.message}`));
+    process.exit(1);
+  }
+}

package/src/commands/label.js

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import api from '../lib/api.js';
+import { getToken, loadProjectConfig } from '../lib/config.js';
+
+function requireAuth() {
+  if (!getToken()) {
+    console.error(chalk.red('Not logged in. Run: kanon login'));
+    process.exit(1);
+  }
+}
+
+function getBoardId() {
+  const config = loadProjectConfig();
+  const boardId = config?.board_id;
+  if (!boardId) throw new Error('No board configured. Run: kanon init');
+  return boardId;
+}
+
+// --- kanon label create "name" [--color "#hex"] ---
+
+export async function labelCreateCommand(name, options) {
+  requireAuth();
+  try {
+    const boardId = getBoardId();
+    const color = options.color || '#888888';
+    const result = await api.createBoardLabel(boardId, name, color);
+    const id = result.label?.id || result.id;
+    console.log(chalk.green(`Label "${name}" created (${id}).`));
+  } catch (err) {
+    console.error(chalk.red(`Failed to create label: ${err.message}`));
+    process.exit(1);
+  }
+}
+
+// --- kanon label delete "name" ---
+
+export async function labelDeleteCommand(name) {
+  requireAuth();
+  try {
+    const boardId = getBoardId();
+    const data = await api.getBoard(boardId, { cardLimit: 0 });
+    const board = data.board || data;
+    const lower = name.toLowerCase();
+    const label = (board.labels || []).find(l => l.name.toLowerCase() === lower);
+    if (!label) {
+      const available = (board.labels || []).map(l => l.name).join(', ');
+      console.error(chalk.red(`Label "${name}" not found. Available: ${available}`));
+      process.exit(1);
+    }
+    if (typeof api.deleteBoardLabel === 'function') {
+      await api.deleteBoardLabel(boardId, label.id);
+      console.log(chalk.green(`Label "${name}" deleted.`));
+    } else {
+      console.error(chalk.red('Label deletion not supported by current API.'));
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error(chalk.red(`Failed to delete label: ${err.message}`));
+    process.exit(1);
+  }
+}