kanon-cli 0.1.0

package/src/lib/claude.js

@@ -0,0 +1,161 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+// Resolve the bin/ directory so `kanon` is in PATH for spawned Claude sessions
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const kanonBinDir = path.resolve(__dirname, '../../bin');
+
+/** Active Claude processes indexed by cardId */
+const activeWorkers = new Map();
+
+/**
+ * Spawn a Claude Code process for a card.
+ * Returns a WorkerInfo object tracked by the agent controller.
+ */
+export function spawnClaude(cardId, prompt, config = {}) {
+  if (activeWorkers.has(cardId)) {
+    console.log(chalk.yellow(`Worker already running for card ${cardId}, skipping.`));
+    return null;
+  }
+
+  const claudeCmd = config.command || 'claude';
+  const defaultArgs = '--print\n--output-format stream-json\n--verbose\n--dangerously-skip-permissions';
+  const argsStr = config.args || defaultArgs;
+  // Parse args: split by lines, strip comments, then split each line by whitespace
+  const args = [
+    ...argsStr
+      .split('\n')
+      .map(line => line.replace(/#.*$/, '').trim())  // strip comments
+      .filter(Boolean)
+      .flatMap(line => line.split(/\s+/)),           // split remaining into tokens
+    prompt,
+  ];
+
+  const projectDir = config.project_dir || process.cwd();
+
+  const worker = {
+    cardId,
+    startedAt: Date.now(),
+    lastOutput: Date.now(),
+    output: [],
+    exitCode: null,
+    process: null,
+  };
+
+  const proc = spawn(claudeCmd, args, {
+    cwd: projectDir,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: process.platform === 'win32',
+    env: { ...process.env, PATH: `${kanonBinDir}:${process.env.PATH}` },
+  });
+
+  worker.process = proc;
+
+  // Buffer for incomplete JSON lines from stream-json output
+  let stdoutBuf = '';
+
+  proc.stdout.on('data', (data) => {
+    stdoutBuf += data.toString();
+    const lines = stdoutBuf.split('\n');
+    // Keep the last (possibly incomplete) chunk in the buffer
+    stdoutBuf = lines.pop() || '';
+
+    for (const raw of lines) {
+      const trimmed = raw.trim();
+      if (!trimmed) continue;
+
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        // Not valid JSON – store raw line as-is
+        worker.lastOutput = Date.now();
+        worker.output.push(trimmed);
+        if (worker.output.length > 100) worker.output.shift();
+        continue;
+      }
+
+      worker.lastOutput = Date.now();
+
+      // Extract human-readable summary from stream-json messages
+      if (parsed.type === 'assistant' && parsed.message?.content) {
+        for (const block of parsed.message.content) {
+          if (block.type === 'text' && block.text) {
+            worker.output.push(block.text);
+          } else if (block.type === 'tool_use') {
+            const name = block.name || 'unknown';
+            const inputPreview = block.input
+              ? JSON.stringify(block.input).substring(0, 120)
+              : '';
+            worker.output.push(`[Tool: ${name}] ${inputPreview}`);
+          }
+          if (worker.output.length > 100) worker.output.shift();
+        }
+      } else if (parsed.type === 'result' && parsed.result) {
+        worker.output.push(`[Result] ${parsed.result.substring(0, 200)}`);
+        if (worker.output.length > 100) worker.output.shift();
+      } else if (parsed.type === 'error') {
+        worker.output.push(`[Error] ${parsed.error?.message || JSON.stringify(parsed)}`);
+        if (worker.output.length > 100) worker.output.shift();
+      }
+      // Silently skip other message types (system, etc.)
+    }
+  });
+
+  proc.stderr.on('data', (data) => {
+    const line = data.toString();
+    worker.lastOutput = Date.now();
+    worker.output.push(`[stderr] ${line}`);
+    if (worker.output.length > 100) worker.output.shift();
+  });
+
+  proc.on('close', (code) => {
+    worker.exitCode = code;
+    activeWorkers.delete(cardId);
+    console.log(chalk.dim(`Worker for card ${cardId} exited with code ${code}`));
+  });
+
+  proc.on('error', (err) => {
+    console.error(chalk.red(`Failed to spawn Claude for card ${cardId}:`), err.message);
+    activeWorkers.delete(cardId);
+  });
+
+  activeWorkers.set(cardId, worker);
+  return worker;
+}
+
+/**
+ * Kill a running worker for a card.
+ */
+export function killWorker(cardId) {
+  const worker = activeWorkers.get(cardId);
+  if (worker?.process) {
+    worker.process.kill('SIGTERM');
+    // Force kill after 5s
+    setTimeout(() => {
+      if (worker.process && !worker.process.killed) {
+        worker.process.kill('SIGKILL');
+      }
+    }, 5000);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get all active workers.
+ */
+export function getActiveWorkers() {
+  return activeWorkers;
+}
+
+/**
+ * Get worker count.
+ */
+export function getWorkerCount() {
+  return activeWorkers.size;
+}
+
+export default { spawnClaude, killWorker, getActiveWorkers, getWorkerCount };

package/src/lib/config.js

@@ -0,0 +1,112 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import YAML from 'yaml';
+
+const GLOBAL_DIR = path.join(os.homedir(), '.kanon');
+const GLOBAL_CONFIG_PATH = path.join(GLOBAL_DIR, 'config.yaml');
+const PROJECT_CONFIG_NAME = 'kanon.config.yaml';
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// --- Global config (~/.kanon/config.yaml) ---
+
+export function loadGlobalConfig() {
+  if (!fs.existsSync(GLOBAL_CONFIG_PATH)) return {};
+  const raw = fs.readFileSync(GLOBAL_CONFIG_PATH, 'utf8');
+  return YAML.parse(raw) || {};
+}
+
+export function saveGlobalConfig(obj) {
+  ensureDir(GLOBAL_DIR);
+  fs.writeFileSync(GLOBAL_CONFIG_PATH, YAML.stringify(obj), 'utf8');
+}
+
+export function getToken() {
+  return loadGlobalConfig().token || null;
+}
+
+export function getUserId() {
+  return loadGlobalConfig().user_id || null;
+}
+
+export function getServerUrl() {
+  const project = loadProjectConfig();
+  if (project?.server_url) return project.server_url;
+  const global = loadGlobalConfig();
+  return global.server_url || 'https://kanones.com';
+}
+
+// --- Project config (./kanon.config.yaml) ---
+
+/**
+ * Detect old single-board format (top-level board_id) and convert to boards array.
+ * Returns migrated config in-memory (does not save to disk).
+ */
+export function migrateConfig(config) {
+  if (!config) return config;
+  // Already migrated
+  if (config.boards) return config;
+  // No board_id means nothing to migrate
+  if (!config.board_id) return config;
+
+  const boardIds = Array.isArray(config.board_id) ? config.board_id : [config.board_id];
+  const boards = boardIds.map((id, i) => ({
+    id,
+    name: `Board ${i + 1}`,
+    active: true,
+    bundle_queue: config.admin?.bundle_queue ?? true,
+    claude: { ...config.claude },
+    watch: { ...config.watch },
+    rules: config.rules ? JSON.parse(JSON.stringify(config.rules)) : {},
+    prompts: config.prompts ? JSON.parse(JSON.stringify(config.prompts)) : {},
+  }));
+
+  const { board_id, claude, watch, rules, prompts, ...rest } = config;
+  return { ...rest, boards };
+}
+
+export function loadProjectConfig() {
+  const configPath = path.join(process.cwd(), PROJECT_CONFIG_NAME);
+  if (!fs.existsSync(configPath)) return null;
+  const raw = fs.readFileSync(configPath, 'utf8');
+  const config = YAML.parse(raw) || {};
+  return migrateConfig(config);
+}
+
+export function saveProjectConfig(obj) {
+  const configPath = path.join(process.cwd(), PROJECT_CONFIG_NAME);
+  fs.writeFileSync(configPath, YAML.stringify(obj), 'utf8');
+}
+
+/**
+ * Get IDs of all active boards from config.
+ */
+export function getActiveBoardIds(config) {
+  if (!config?.boards) return [];
+  return config.boards.filter(b => b.active).map(b => b.id);
+}
+
+/**
+ * Get full config for a specific board.
+ */
+export function getBoardConfig(config, boardId) {
+  if (!config?.boards) return null;
+  return config.boards.find(b => b.id === boardId) || null;
+}
+
+// --- Status file (~/.kanon/status.json) ---
+
+export function getStatusPath() {
+  return path.join(GLOBAL_DIR, 'status.json');
+}
+
+export function getAgentLockPath() {
+  return path.join(GLOBAL_DIR, 'agent.lock');
+}
+
+export { GLOBAL_DIR, GLOBAL_CONFIG_PATH, PROJECT_CONFIG_NAME };

package/src/lib/pipeline.js

@@ -0,0 +1,133 @@
+// Event trigger logic for the Kanon watch daemon.
+// Uses the `rules` config structure: rules.labels[] and rules.events.{}
+
+/**
+ * Determine if an event should trigger the agent.
+ * Returns { trigger, extraPrompt, extraArgs }.
+ */
+export function shouldTrigger(event, config, ownUserId) {
+  const { eventType, eventData, userId } = event;
+
+  // Never trigger on own events (unless explicitly disabled)
+  if (config?.watch?.ignore_own_events !== false && userId === ownUserId) {
+    return { trigger: false, extraPrompt: '', extraArgs: '' };
+  }
+
+  const rules = config?.rules || {};
+  const labels = rules.labels || [];
+  const events = rules.events || {};
+
+  // --- Label triggers (only labels with trigger: true or trigger undefined) ---
+  if (eventType === 'label_added') {
+    const labelName = eventData?.label_name || '';
+    const match = labels.find(l =>
+      l.enabled !== false &&
+      l.trigger !== false &&
+      labelName.toLowerCase().includes(l.name.toLowerCase())
+    );
+    if (match) {
+      return { trigger: true, extraPrompt: match.prompt || '', extraArgs: match.args || '' };
+    }
+    return { trigger: false, extraPrompt: '', extraArgs: '' };
+  }
+
+  // --- List triggers (card_moved) ---
+  if (eventType === 'card_moved') {
+    const listRules = rules.lists || [];
+    const listName = eventData?.to_list || eventData?.list_name || '';
+    const match = listRules.find(l =>
+      l.enabled !== false &&
+      l.trigger !== false &&
+      listName.toLowerCase().includes(l.name.toLowerCase())
+    );
+    if (match) {
+      return { trigger: true, extraPrompt: match.prompt || '', extraArgs: match.args || '' };
+    }
+    return { trigger: false, extraPrompt: '', extraArgs: '' };
+  }
+
+  // --- Event triggers ---
+
+  if ((eventType === 'card_assigned' || eventType === 'member_added') && (eventData?.assignee_id === ownUserId || eventData?.member_id === ownUserId)) {
+    const rule = events.agent_assigned;
+    const enabled = rule?.enabled ?? true;
+    if (enabled) {
+      return {
+        trigger: true,
+        extraPrompt: rule?.prompt || 'You were just assigned to this card. Read the content carefully. If there is a task, execute it. If you need more information, add a comment with your questions.',
+        extraArgs: rule?.args || '',
+      };
+    }
+    return { trigger: false, extraPrompt: '', extraArgs: '' };
+  }
+
+  if (eventType === 'comment_added') {
+    const rule = events.comment_added;
+    if (rule?.enabled) {
+      // scope: 'assigned' means only trigger for cards assigned to the agent
+      // The actual assignee check happens in watch.js after fetching the card
+      return {
+        trigger: true,
+        scope: rule.scope || 'assigned',
+        extraPrompt: rule?.prompt || 'A new comment was added. Read it and determine if any action is needed.',
+        extraArgs: rule?.args || '',
+      };
+    }
+    return { trigger: false, extraPrompt: '', extraArgs: '' };
+  }
+
+  if (eventType === 'due_date_changed') {
+    const rule = events.due_date_changed;
+    if (rule?.enabled) {
+      return {
+        trigger: true,
+        scope: rule.scope || 'assigned',
+        extraPrompt: rule?.prompt || 'The due date on this card was changed. Review the card and adjust your priorities if needed.',
+        extraArgs: rule?.args || '',
+      };
+    }
+    return { trigger: false, extraPrompt: '', extraArgs: '' };
+  }
+
+  return { trigger: false, extraPrompt: '', extraArgs: '' };
+}
+
+/**
+ * Collect extra prompts and args from context-only labels and lists on a card.
+ * These have trigger: false but provide additional instructions when present.
+ */
+export function getContextFromLabels(card, config) {
+  const labels = config?.rules?.labels || [];
+  const listRules = config?.rules?.lists || [];
+  const cardLabels = card.labels || [];
+  let extraPrompt = '';
+  let extraArgs = '';
+
+  // Context from labels
+  for (const rule of labels) {
+    if (rule.enabled === false || rule.trigger !== false) continue;
+    const match = cardLabels.some(cl =>
+      cl.name.toLowerCase().includes(rule.name.toLowerCase())
+    );
+    if (match) {
+      if (rule.prompt) extraPrompt += (extraPrompt ? '\n' : '') + rule.prompt;
+      if (rule.args) extraArgs += (extraArgs ? ' ' : '') + rule.args;
+    }
+  }
+
+  // Context from lists (check which list the card is in by list_id)
+  // Note: card.list_id is the ID, but we need to match by name.
+  // The card object from the API includes list info if available, otherwise
+  // we match on list_name if provided in the card data.
+  for (const rule of listRules) {
+    if (rule.enabled === false || rule.trigger !== false) continue;
+    // Match by list_name if available on card, or by list title from board context
+    const cardListName = card.list_name || card.list_title || '';
+    if (cardListName && cardListName.toLowerCase().includes(rule.name.toLowerCase())) {
+      if (rule.prompt) extraPrompt += (extraPrompt ? '\n' : '') + rule.prompt;
+      if (rule.args) extraArgs += (extraArgs ? ' ' : '') + rule.args;
+    }
+  }
+
+  return { extraPrompt, extraArgs };
+}

package/src/lib/websocket.js

@@ -0,0 +1,194 @@
+import WebSocket from 'ws';
+import chalk from 'chalk';
+
+export class KanonWebSocket {
+  constructor(serverUrl, token, userInfo = {}) {
+    this.serverUrl = serverUrl;
+    this.token = token;
+    this.userInfo = userInfo;
+    this.ws = null;
+    this.isConnected = false;
+    this.isAuthenticated = false;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 50; // Long-running daemon
+    this.reconnectDelay = 1000;
+    this.listeners = new Map();
+    this.boardIds = new Set();
+    this.pingInterval = null;
+    this._closing = false;
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        resolve();
+        return;
+      }
+
+      // Convert https:// to wss://, http:// to ws://
+      const wsUrl = this.serverUrl
+        .replace(/^https:/, 'wss:')
+        .replace(/^http:/, 'ws:') + '/ws';
+
+      try {
+        this.ws = new WebSocket(wsUrl);
+
+        this.ws.on('open', () => {
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          // Authenticate
+          this._send({ type: 'auth', token: this.token });
+          this._startPing();
+        });
+
+        this.ws.on('message', (raw) => {
+          try {
+            const data = JSON.parse(raw.toString());
+            this._handleMessage(data, resolve);
+          } catch (err) {
+            console.error(chalk.red('WS message parse error:'), err.message);
+          }
+        });
+
+        this.ws.on('close', () => {
+          this.isConnected = false;
+          this.isAuthenticated = false;
+          this._stopPing();
+          if (!this._closing) {
+            this._attemptReconnect();
+          }
+        });
+
+        this.ws.on('error', (err) => {
+          if (!this.isConnected) {
+            reject(err);
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  joinBoard(boardId) {
+    this.boardIds.add(boardId);
+    if (this.isAuthenticated) {
+      this._send({
+        type: 'join_board',
+        boardId,
+        user: this.userInfo,
+      });
+    }
+  }
+
+  leaveBoard(boardId) {
+    this.boardIds.delete(boardId);
+    if (this.isAuthenticated) {
+      this._send({ type: 'leave_board', boardId });
+    }
+  }
+
+  on(eventType, callback) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, new Set());
+    }
+    this.listeners.get(eventType).add(callback);
+    return () => this.listeners.get(eventType)?.delete(callback);
+  }
+
+  disconnect() {
+    this._closing = true;
+    this._stopPing();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.isAuthenticated = false;
+  }
+
+  // --- Internal ---
+
+  _send(data) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+
+  _handleMessage(data, onAuthResolve) {
+    const { type } = data;
+
+    if (type === 'auth_success') {
+      this.isAuthenticated = true;
+      // Re-join all boards after auth
+      for (const boardId of this.boardIds) {
+        this._send({
+          type: 'join_board',
+          boardId,
+          user: this.userInfo,
+        });
+      }
+      if (onAuthResolve) onAuthResolve();
+      return;
+    }
+
+    if (type === 'auth_error') {
+      console.error(chalk.red('WebSocket auth failed:'), data.error);
+      return;
+    }
+
+    if (type === 'pong') return;
+
+    // Notify type-specific listeners
+    const typeListeners = this.listeners.get(type);
+    if (typeListeners) {
+      typeListeners.forEach(cb => cb(data));
+    }
+
+    // Notify 'all' listeners
+    const allListeners = this.listeners.get('all');
+    if (allListeners) {
+      allListeners.forEach(cb => cb(data));
+    }
+  }
+
+  _attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.log(chalk.red('Max reconnection attempts reached.'));
+      this._emit('max_reconnect');
+      return;
+    }
+
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.min(2 ** (this.reconnectAttempts - 1), 16);
+
+    console.log(chalk.yellow(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`));
+
+    setTimeout(() => {
+      if (!this._closing) {
+        this.connect().catch(() => {});
+      }
+    }, delay);
+  }
+
+  _emit(type, data) {
+    const listeners = this.listeners.get(type);
+    if (listeners) listeners.forEach(cb => cb(data));
+  }
+
+  _startPing() {
+    this._stopPing();
+    this.pingInterval = setInterval(() => {
+      this._send({ type: 'ping' });
+    }, 25000); // Slightly under server's 30s heartbeat
+  }
+
+  _stopPing() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+}
+
+export default KanonWebSocket;