circuschief 0.1.0

package/packages/server/src/db/KanbanCardRepository.js

@@ -0,0 +1,286 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Kanban card repository class
+ */
+export class KanbanCardRepository extends BaseRepository {
+  constructor() {
+    super('kanban_cards', KanbanCardRepository.#mapCard);
+  }
+
+  static #mapCard(row) {
+    const card = {
+      id: row.id,
+      laneId: row.lane_id,
+      sortOrder: row.sort_order,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+
+    // If session data is joined, include it
+    if (row.session_id !== undefined) {
+      card.sessions = row.session_id
+        ? [
+            {
+              id: row.session_id,
+              name: row.session_name,
+              status: row.session_status,
+              mode: row.session_mode,
+              costUsd: row.session_cost_usd,
+              starred: Boolean(row.session_starred),
+              prUrl: row.session_pr_url,
+              createdAt: row.session_created_at,
+              updatedAt: row.session_updated_at,
+            },
+          ]
+        : [];
+    }
+
+    return card;
+  }
+
+  /**
+   * Get all cards for a lane with session data, ordered by sort_order
+   * @param {string} laneId
+   * @returns {Array}
+   */
+  getByLaneId(laneId) {
+    const rows = this.db
+      .prepare(
+        `SELECT kc.*,
+                kcs.session_id,
+                s.name as session_name,
+                s.status as session_status,
+                s.mode as session_mode,
+                s.cost_usd as session_cost_usd,
+                s.starred as session_starred,
+                s.pr_url as session_pr_url,
+                s.created_at as session_created_at,
+                s.updated_at as session_updated_at
+         FROM kanban_cards kc
+         LEFT JOIN kanban_card_sessions kcs ON kc.id = kcs.card_id
+         LEFT JOIN sessions s ON kcs.session_id = s.id
+         WHERE kc.lane_id = ?
+         ORDER BY kc.sort_order`
+      )
+      .all(laneId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get all cards for a board with session data
+   * @param {string} boardId
+   * @returns {Array}
+   */
+  getByBoardId(boardId) {
+    const rows = this.db
+      .prepare(
+        `SELECT kc.*,
+                kcs.session_id,
+                s.name as session_name,
+                s.status as session_status,
+                s.mode as session_mode,
+                s.cost_usd as session_cost_usd,
+                s.starred as session_starred,
+                s.pr_url as session_pr_url,
+                s.created_at as session_created_at,
+                s.updated_at as session_updated_at
+         FROM kanban_cards kc
+         JOIN kanban_lanes kl ON kc.lane_id = kl.id
+         LEFT JOIN kanban_card_sessions kcs ON kc.id = kcs.card_id
+         LEFT JOIN sessions s ON kcs.session_id = s.id
+         WHERE kl.board_id = ?
+         ORDER BY kl.sort_order, kc.sort_order`
+      )
+      .all(boardId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get the card for a specific session
+   * @param {string} sessionId
+   * @returns {Object|null}
+   */
+  getBySessionId(sessionId) {
+    const row = this.db
+      .prepare(
+        `SELECT kc.*,
+                kcs.session_id,
+                s.name as session_name,
+                s.status as session_status,
+                s.mode as session_mode,
+                s.cost_usd as session_cost_usd,
+                s.starred as session_starred,
+                s.pr_url as session_pr_url,
+                s.created_at as session_created_at,
+                s.updated_at as session_updated_at
+         FROM kanban_cards kc
+         JOIN kanban_card_sessions kcs ON kc.id = kcs.card_id
+         LEFT JOIN sessions s ON kcs.session_id = s.id
+         WHERE kcs.session_id = ?`
+      )
+      .get(sessionId);
+    return this.map(row);
+  }
+
+  /**
+   * Create a card for a session in a lane
+   * @param {string} laneId
+   * @param {string} sessionId
+   * @param {Object} [options]
+   * @param {number} [options.sortOrder]
+   * @returns {Object}
+   */
+  create(laneId, sessionId, options = {}) {
+    const cardId = databaseManager.generateId();
+    const cardSessionId = databaseManager.generateId();
+    const now = Date.now();
+
+    // If no sortOrder provided, put it at the end
+    let sortOrder = options.sortOrder;
+    if (sortOrder === undefined || sortOrder === null) {
+      const maxRow = this.db
+        .prepare('SELECT MAX(sort_order) as max_order FROM kanban_cards WHERE lane_id = ?')
+        .get(laneId);
+      sortOrder = (maxRow?.max_order ?? -1) + 1;
+    }
+
+    return databaseManager.transaction(() => {
+      // Create the card
+      this.db
+        .prepare(
+          `INSERT INTO kanban_cards (id, lane_id, sort_order, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?)`
+        )
+        .run(cardId, laneId, sortOrder, now, now);
+
+      // Link the session to the card
+      this.db
+        .prepare(
+          `INSERT INTO kanban_card_sessions (id, card_id, session_id, created_at)
+           VALUES (?, ?, ?, ?)`
+        )
+        .run(cardSessionId, cardId, sessionId, now);
+
+      return this.getBySessionId(sessionId);
+    });
+  }
+
+  /**
+   * Move a card to a different lane
+   * @param {string} cardId
+   * @param {string} targetLaneId
+   * @param {number} [sortOrder]
+   * @returns {Object}
+   */
+  moveToLane(cardId, targetLaneId, sortOrder) {
+    const now = Date.now();
+
+    // If no sortOrder provided, put it at the end of the target lane
+    let order = sortOrder;
+    if (order === undefined || order === null) {
+      const maxRow = this.db
+        .prepare('SELECT MAX(sort_order) as max_order FROM kanban_cards WHERE lane_id = ?')
+        .get(targetLaneId);
+      order = (maxRow?.max_order ?? -1) + 1;
+    }
+
+    this.db
+      .prepare('UPDATE kanban_cards SET lane_id = ?, sort_order = ?, updated_at = ? WHERE id = ?')
+      .run(targetLaneId, order, now, cardId);
+
+    return this.getById(cardId);
+  }
+
+  /**
+   * Reorder cards within a lane
+   * @param {string} laneId
+   * @param {string[]} cardIds - Ordered array of card IDs
+   */
+  reorder(laneId, cardIds) {
+    const now = Date.now();
+
+    databaseManager.transaction(() => {
+      const updateStmt = this.db.prepare(
+        'UPDATE kanban_cards SET sort_order = ?, updated_at = ? WHERE id = ? AND lane_id = ?'
+      );
+
+      cardIds.forEach((cardId, index) => {
+        updateStmt.run(index, now, cardId, laneId);
+      });
+    });
+  }
+
+  /**
+   * Delete a card (does not delete the session)
+   * @param {string} cardId
+   */
+  delete(cardId) {
+    super.delete(cardId);
+  }
+
+  /**
+   * Get card by ID with full session data
+   * @param {string} id
+   * @returns {Object|null}
+   */
+  getById(id) {
+    const row = this.db
+      .prepare(
+        `SELECT kc.*,
+                kcs.session_id,
+                s.name as session_name,
+                s.status as session_status,
+                s.mode as session_mode,
+                s.cost_usd as session_cost_usd,
+                s.starred as session_starred,
+                s.pr_url as session_pr_url,
+                s.created_at as session_created_at,
+                s.updated_at as session_updated_at
+         FROM kanban_cards kc
+         LEFT JOIN kanban_card_sessions kcs ON kc.id = kcs.card_id
+         LEFT JOIN sessions s ON kcs.session_id = s.id
+         WHERE kc.id = ?`
+      )
+      .get(id);
+    return this.map(row);
+  }
+
+  /**
+   * Get card with lane info (useful for knowing current lane when moving)
+   * @param {string} id
+   * @returns {Object|null}
+   */
+  getByIdWithLane(id) {
+    const row = this.db
+      .prepare(
+        `SELECT kc.*,
+                kl.board_id,
+                kl.name as lane_name,
+                kcs.session_id,
+                s.name as session_name,
+                s.status as session_status,
+                s.mode as session_mode,
+                s.cost_usd as session_cost_usd,
+                s.starred as session_starred,
+                s.pr_url as session_pr_url,
+                s.created_at as session_created_at,
+                s.updated_at as session_updated_at
+         FROM kanban_cards kc
+         JOIN kanban_lanes kl ON kc.lane_id = kl.id
+         LEFT JOIN kanban_card_sessions kcs ON kc.id = kcs.card_id
+         LEFT JOIN sessions s ON kcs.session_id = s.id
+         WHERE kc.id = ?`
+      )
+      .get(id);
+
+    if (!row) return null;
+
+    return {
+      ...this.map(row),
+      boardId: row.board_id,
+      laneName: row.lane_name,
+    };
+  }
+}

package/packages/server/src/db/KanbanLaneRepository.js

@@ -0,0 +1,279 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Convert a boolean value to SQLite integer (1/0) or null.
+ * @param {boolean|null|undefined} value
+ * @param {number|null} [defaultValue] - Default value if undefined
+ * @returns {number|null}
+ */
+function boolToSqlite(value, defaultValue = null) {
+  if (value === undefined) return defaultValue;
+  if (value === null) return null;
+  return value ? 1 : 0;
+}
+
+/**
+ * Prepare lane insert values from data object.
+ * @param {Object} data - Lane data
+ * @returns {Array} Array of values for INSERT
+ */
+function prepareLaneValues(data) {
+  return [
+    data.onEnterTemplateId || null,
+    data.onEnterPrompt || null,
+    data.onEnterMode || null,
+    data.onEnterModel || null,
+    data.onEnterEffortLevel || null,
+    boolToSqlite(data.onEnterThinkingEnabled),
+    data.onEnterAutoRescheduleEnabled ? 1 : 0,
+    data.onEnterRescheduleDelayMinutes ?? 15,
+    boolToSqlite(data.onEnterRescheduleOnTokenLimit, 1),
+    boolToSqlite(data.onEnterRescheduleOnServiceError, 1),
+    data.onEnterMaxRescheduleCount ?? null,
+    data.onEnterMaxTotalTokens ?? null,
+    data.onEnterRescheduleAtTokenCount ?? null,
+  ];
+}
+
+/**
+ * Boolean field configurations for update operations.
+ * - nullable: true means null values are preserved (converts to null in DB)
+ * - nullable: false means values are coerced to 0/1
+ */
+const BOOLEAN_FIELDS = {
+  onEnterThinkingEnabled: { nullable: true },
+  onEnterAutoRescheduleEnabled: { nullable: false },
+  onEnterRescheduleOnTokenLimit: { nullable: false },
+  onEnterRescheduleOnServiceError: { nullable: false },
+};
+
+/**
+ * Convert a field value for SQL update, handling booleans specially.
+ * @param {string} fieldName - The camelCase field name
+ * @param {*} value - The value to convert
+ * @returns {*} The converted value
+ */
+function convertFieldValue(fieldName, value) {
+  const boolConfig = BOOLEAN_FIELDS[fieldName];
+  if (!boolConfig) {
+    return value;
+  }
+  if (boolConfig.nullable && value === null) {
+    return null;
+  }
+  return value ? 1 : 0;
+}
+
+/**
+ * Kanban lane repository class
+ */
+export class KanbanLaneRepository extends BaseRepository {
+  constructor() {
+    super('kanban_lanes', KanbanLaneRepository.#mapLane);
+  }
+
+  static #mapLane(row) {
+    return {
+      id: row.id,
+      boardId: row.board_id,
+      name: row.name,
+      sortOrder: row.sort_order,
+      onEnterTemplateId: row.on_enter_template_id,
+      onEnterPrompt: row.on_enter_prompt,
+      onEnterMode: row.on_enter_mode,
+      onEnterModel: row.on_enter_model,
+      onEnterEffortLevel: row.on_enter_effort_level,
+      onEnterThinkingEnabled: row.on_enter_thinking_enabled === null ? null : Boolean(row.on_enter_thinking_enabled),
+      onEnterAutoRescheduleEnabled: Boolean(row.on_enter_auto_reschedule_enabled),
+      onEnterRescheduleDelayMinutes: row.on_enter_reschedule_delay_minutes,
+      onEnterRescheduleOnTokenLimit: row.on_enter_reschedule_on_token_limit === null ? null : Boolean(row.on_enter_reschedule_on_token_limit),
+      onEnterRescheduleOnServiceError: row.on_enter_reschedule_on_service_error === null ? null : Boolean(row.on_enter_reschedule_on_service_error),
+      onEnterMaxRescheduleCount: row.on_enter_max_reschedule_count,
+      onEnterMaxTotalTokens: row.on_enter_max_total_tokens,
+      onEnterRescheduleAtTokenCount: row.on_enter_reschedule_at_token_count,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get all lanes for a board, ordered by sort_order
+   * @param {string} boardId
+   * @returns {Array}
+   */
+  getByBoardId(boardId) {
+    const rows = this.db
+      .prepare('SELECT * FROM kanban_lanes WHERE board_id = ? ORDER BY sort_order')
+      .all(boardId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Create a new lane
+   * @param {string} boardId
+   * @param {Object} data
+   * @param {string} data.name
+   * @param {number} [data.sortOrder]
+   * @param {string|null} [data.onEnterTemplateId]
+   * @param {string|null} [data.onEnterPrompt]
+   * @returns {Object}
+   */
+  create(boardId, data) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    const sortOrder = this.#resolveSortOrder(boardId, data.sortOrder);
+    const laneValues = prepareLaneValues(data);
+
+    this.db
+      .prepare(
+        `INSERT INTO kanban_lanes (
+          id, board_id, name, sort_order, on_enter_template_id, on_enter_prompt,
+          on_enter_mode, on_enter_model, on_enter_effort_level, on_enter_thinking_enabled,
+          on_enter_auto_reschedule_enabled, on_enter_reschedule_delay_minutes,
+          on_enter_reschedule_on_token_limit, on_enter_reschedule_on_service_error,
+          on_enter_max_reschedule_count, on_enter_max_total_tokens,
+          on_enter_reschedule_at_token_count,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, boardId, data.name, sortOrder, ...laneValues, now, now);
+
+    return this.getById(id);
+  }
+
+  /**
+   * Resolve sort order, defaulting to end of list if not provided.
+   * @param {string} boardId
+   * @param {number|undefined|null} sortOrder
+   * @returns {number}
+   */
+  #resolveSortOrder(boardId, sortOrder) {
+    if (sortOrder !== undefined && sortOrder !== null) {
+      return sortOrder;
+    }
+    const maxRow = this.db
+      .prepare('SELECT MAX(sort_order) as max_order FROM kanban_lanes WHERE board_id = ?')
+      .get(boardId);
+    return (maxRow?.max_order ?? -1) + 1;
+  }
+
+  /**
+   * Update a lane
+   * @param {string} id
+   * @param {Object} data
+   * @param {string} [data.name]
+   * @param {number} [data.sortOrder]
+   * @param {string|null} [data.onEnterTemplateId]
+   * @param {string|null} [data.onEnterPrompt]
+   * @returns {Object}
+   */
+  update(id, data) {
+    // Field mapping: camelCase -> snake_case
+    const fieldMap = {
+      name: 'name',
+      sortOrder: 'sort_order',
+      onEnterTemplateId: 'on_enter_template_id',
+      onEnterPrompt: 'on_enter_prompt',
+      onEnterMode: 'on_enter_mode',
+      onEnterModel: 'on_enter_model',
+      onEnterEffortLevel: 'on_enter_effort_level',
+      onEnterThinkingEnabled: 'on_enter_thinking_enabled',
+      onEnterAutoRescheduleEnabled: 'on_enter_auto_reschedule_enabled',
+      onEnterRescheduleDelayMinutes: 'on_enter_reschedule_delay_minutes',
+      onEnterRescheduleOnTokenLimit: 'on_enter_reschedule_on_token_limit',
+      onEnterRescheduleOnServiceError: 'on_enter_reschedule_on_service_error',
+      onEnterMaxRescheduleCount: 'on_enter_max_reschedule_count',
+      onEnterMaxTotalTokens: 'on_enter_max_total_tokens',
+      onEnterRescheduleAtTokenCount: 'on_enter_reschedule_at_token_count',
+    };
+
+    const updates = [];
+    const values = [];
+
+    // Build update clauses dynamically
+    for (const [camelKey, snakeKey] of Object.entries(fieldMap)) {
+      if (data[camelKey] !== undefined) {
+        updates.push(`${snakeKey} = ?`);
+        values.push(convertFieldValue(camelKey, data[camelKey]));
+      }
+    }
+
+    if (updates.length === 0) return this.getById(id);
+
+    updates.push('updated_at = ?');
+    values.push(Date.now());
+    values.push(id);
+
+    this.db.prepare(`UPDATE kanban_lanes SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+
+    return this.getById(id);
+  }
+
+  /**
+   * Reorder lanes based on an array of lane IDs
+   * @param {string} boardId
+   * @param {string[]} laneIds - Ordered array of lane IDs
+   */
+  reorder(boardId, laneIds) {
+    const now = Date.now();
+
+    databaseManager.transaction(() => {
+      const updateStmt = this.db.prepare(
+        'UPDATE kanban_lanes SET sort_order = ?, updated_at = ? WHERE id = ? AND board_id = ?'
+      );
+
+      laneIds.forEach((laneId, index) => {
+        updateStmt.run(index, now, laneId, boardId);
+      });
+    });
+  }
+
+  /**
+   * Get a single lane with its board info
+   * @param {string} id
+   * @returns {Object|null}
+   */
+  getById(id) {
+    const row = this.db.prepare('SELECT * FROM kanban_lanes WHERE id = ?').get(id);
+    return this.map(row);
+  }
+
+  /**
+   * Get lane by ID with template info (for on-enter triggers)
+   * @param {string} id
+   * @returns {Object|null}
+   */
+  getByIdWithTemplate(id) {
+    const row = this.db
+      .prepare(
+        `SELECT kl.*, st.name as template_name, st.prompt as template_prompt
+         FROM kanban_lanes kl
+         LEFT JOIN session_templates st ON kl.on_enter_template_id = st.id
+         WHERE kl.id = ?`
+      )
+      .get(id);
+
+    if (!row) return null;
+
+    const mappedLane = this.map(row);
+    return {
+      ...mappedLane,
+      template: row.template_name
+        ? {
+            id: row.on_enter_template_id,
+            name: row.template_name,
+            prompt: row.template_prompt,
+          }
+        : null,
+    };
+  }
+
+  /**
+   * Delete a lane
+   * @param {string} id
+   */
+  delete(id) {
+    super.delete(id);
+  }
+}