circuschief 0.1.0

package/packages/server/src/database.js

@@ -0,0 +1,58 @@
+// Re-export everything from db module for backward compatibility
+export {
+  // Classes
+  DatabaseManager,
+  BaseRepository,
+  ProjectRepository,
+  ProjectDefaultsRepository,
+  SessionRepository,
+  SessionTemplateRepository,
+  MessageRepository,
+  ConversationRepository,
+  CanvasItemRepository,
+  SessionNoteRepository,
+  TodoRepository,
+  WorkLogRepository,
+  SessionSummaryRepository,
+  AttachmentRepository,
+  CommandButtonRepository,
+  CommandRunRepository,
+  QuickResponseRepository,
+  ProviderRepository,
+  // Kept for any code that still imports ModelProviderRepository by name
+  ModelProviderRepository,
+  SettingsRepository,
+  AgentCallLogRepository,
+  KanbanBoardRepository,
+  KanbanLaneRepository,
+  KanbanCardRepository,
+  // Singleton instances
+  databaseManager,
+  projects,
+  projectDefaults,
+  sessions,
+  sessionTemplates,
+  messages,
+  conversations,
+  canvasItems,
+  sessionNotes,
+  todos,
+  workLogs,
+  sessionSummaries,
+  attachments,
+  commandButtons,
+  commandRuns,
+  quickResponses,
+  modelProviders,
+  settings,
+  agentCallLogs,
+  kanbanBoards,
+  kanbanLanes,
+  kanbanCards,
+  // Legacy functions
+  initDatabase,
+  getDatabase,
+  closeDatabase,
+  generateId,
+  transaction,
+} from './db/index.js';

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

@@ -0,0 +1,322 @@
+import { BaseRepository } from './BaseRepository.js';
+
+/**
+ * Compute total tokens from passed values (preferring provided over DB row values).
+ */
+function computeTotalTokens(provided, row) {
+  const finalInput = provided.inputTokens ?? row?.input_tokens ?? 0;
+  const finalOutput = provided.outputTokens ?? row?.output_tokens ?? 0;
+  const finalThinking = row?.thinking_tokens ?? 0;
+  const finalCacheRead = provided.cacheReadTokens ?? row?.cache_read_tokens ?? 0;
+  const finalCacheWrite = provided.cacheWriteTokens ?? row?.cache_write_tokens ?? 0;
+  return finalInput + finalOutput + finalThinking + finalCacheRead + finalCacheWrite;
+}
+
+function mapRow(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    conversationId: row.conversation_id,
+    agentType: row.agent_type,
+    model: row.model,
+    callType: row.call_type,
+    promptLength: row.prompt_length,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    thinkingTokens: row.thinking_tokens,
+    cacheReadTokens: row.cache_read_tokens,
+    cacheWriteTokens: row.cache_write_tokens,
+    totalTokens: row.total_tokens,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+    durationMs: row.duration_ms,
+    status: row.status,
+    errorMessage: row.error_message,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+    createdAt: row.created_at,
+  };
+}
+
+export class AgentCallLogRepository extends BaseRepository {
+  constructor() {
+    super('agent_call_logs', mapRow);
+  }
+
+  /**
+   * Create a new call log entry
+   */
+  create({ id, sessionId, conversationId, agentType, model, callType, promptLength, metadata = {} }) {
+    const now = Date.now();
+    const metadataJson = Object.keys(metadata).length > 0
+      ? JSON.stringify(metadata)
+      : null;
+
+    this.db
+      .prepare(
+        `INSERT INTO agent_call_logs (id, session_id, conversation_id, agent_type, model, call_type, prompt_length, metadata, started_at, status, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?)`
+      )
+      .run(id, sessionId, conversationId, agentType, model, callType, promptLength, metadataJson, now, now);
+    return this.getById(id);
+  }
+
+  /**
+   * Update usage tokens during streaming
+   */
+  updateUsage(
+    id,
+    { inputTokens, outputTokens, thinkingTokens, cacheReadTokens, cacheWriteTokens }
+  ) {
+    this.db
+      .prepare(
+        `UPDATE agent_call_logs SET
+        input_tokens = COALESCE(?, input_tokens),
+        output_tokens = COALESCE(?, output_tokens),
+        thinking_tokens = COALESCE(?, thinking_tokens),
+        cache_read_tokens = COALESCE(?, cache_read_tokens),
+        cache_write_tokens = COALESCE(?, cache_write_tokens),
+        status = 'streaming'
+      WHERE id = ?`
+      )
+      .run(inputTokens, outputTokens, thinkingTokens, cacheReadTokens, cacheWriteTokens, id);
+  }
+
+  /**
+   * Mark a call as completed or errored
+   */
+  complete(
+    id,
+    { success, inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, errorMessage }
+  ) {
+    const now = Date.now();
+    const row = this.db
+      .prepare(
+        'SELECT started_at, input_tokens, output_tokens, thinking_tokens, cache_read_tokens, cache_write_tokens FROM agent_call_logs WHERE id = ?'
+      )
+      .get(id);
+    const durationMs = row ? now - row.started_at : null;
+
+    // Compute totalTokens using passed values (if provided) or existing DB values.
+    // thinkingTokens is only set via updateUsage() during streaming, so we always
+    // read it from the existing row rather than expecting it as a parameter here.
+    const totalTokens = computeTotalTokens(
+      { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens },
+      row
+    );
+
+    this.db
+      .prepare(
+        `UPDATE agent_call_logs SET
+        input_tokens = COALESCE(?, input_tokens),
+        output_tokens = COALESCE(?, output_tokens),
+        cache_read_tokens = COALESCE(?, cache_read_tokens),
+        cache_write_tokens = COALESCE(?, cache_write_tokens),
+        total_tokens = ?,
+        completed_at = ?,
+        duration_ms = ?,
+        status = ?,
+        error_message = ?
+      WHERE id = ?`
+      )
+      .run(
+        inputTokens,
+        outputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+        totalTokens,
+        now,
+        durationMs,
+        success ? 'completed' : 'error',
+        errorMessage || null,
+        id
+      );
+  }
+
+  /**
+   * Get all call logs with optional filtering, sorting, and pagination.
+   * Returns { rows, total } where total is the full count (before limit/offset).
+   */
+  getAll({
+    limit = 25,
+    offset = 0,
+    agentType,
+    callType,
+    status,
+    startDate,
+    endDate,
+    sessionId,
+    model,
+    sortBy = 'started_at',
+    sortOrder = 'DESC',
+  } = {}) {
+    const SORTABLE_COLUMNS = [
+      'started_at',
+      'status',
+      'agent_type',
+      'call_type',
+      'model',
+      'total_tokens',
+      'duration_ms',
+    ];
+    const safeSortBy = SORTABLE_COLUMNS.includes(sortBy) ? sortBy : 'started_at';
+    const safeSortOrder = sortOrder === 'ASC' ? 'ASC' : 'DESC';
+
+    const conditions = [];
+    const params = [];
+
+    if (agentType) {
+      conditions.push('acl.agent_type = ?');
+      params.push(agentType);
+    }
+    if (callType) {
+      conditions.push('acl.call_type = ?');
+      params.push(callType);
+    }
+    if (status) {
+      conditions.push('acl.status = ?');
+      params.push(status);
+    }
+    if (model) {
+      conditions.push('acl.model = ?');
+      params.push(model);
+    }
+    if (sessionId) {
+      conditions.push('acl.session_id = ?');
+      params.push(sessionId);
+    }
+    if (startDate) {
+      conditions.push('acl.started_at >= ?');
+      params.push(startDate);
+    }
+    if (endDate) {
+      conditions.push('acl.started_at <= ?');
+      params.push(endDate);
+    }
+
+    const whereClause = conditions.length > 0 ? `WHERE ${  conditions.join(' AND ')}` : '';
+
+    const countRow = this.db
+      .prepare(`SELECT COUNT(*) as count FROM agent_call_logs acl ${whereClause}`)
+      .get(...params);
+    const total = countRow.count;
+
+    const rows = this.db
+      .prepare(
+        `SELECT acl.*, s.name AS session_name
+         FROM agent_call_logs acl
+         LEFT JOIN sessions s ON acl.session_id = s.id
+         ${whereClause}
+         ORDER BY acl.${safeSortBy} ${safeSortOrder}
+         LIMIT ? OFFSET ?`
+      )
+      .all(...params, limit, offset);
+
+    const mappedRows = rows
+      .map((row) => {
+        const mapped = mapRow(row);
+        if (mapped) mapped.sessionName = row.session_name || null;
+        return mapped;
+      })
+      .filter(Boolean);
+
+    return { rows: mappedRows, total };
+  }
+
+  /**
+   * Get distinct filter option values from the database.
+   * Returns { agentTypes, callTypes, statuses, models }
+   */
+  getFilterOptions() {
+    const agentTypes = this.db
+      .prepare(
+        'SELECT DISTINCT agent_type FROM agent_call_logs WHERE agent_type IS NOT NULL ORDER BY agent_type'
+      )
+      .all()
+      .map((r) => r.agent_type);
+    const callTypes = this.db
+      .prepare(
+        'SELECT DISTINCT call_type FROM agent_call_logs WHERE call_type IS NOT NULL ORDER BY call_type'
+      )
+      .all()
+      .map((r) => r.call_type);
+    const statuses = this.db
+      .prepare(
+        'SELECT DISTINCT status FROM agent_call_logs WHERE status IS NOT NULL ORDER BY status'
+      )
+      .all()
+      .map((r) => r.status);
+    const models = this.db
+      .prepare(
+        'SELECT DISTINCT model FROM agent_call_logs WHERE model IS NOT NULL ORDER BY model'
+      )
+      .all()
+      .map((r) => r.model);
+    return { agentTypes, callTypes, statuses, models };
+  }
+
+  /**
+   * Get all call logs for a session
+   */
+  getBySessionId(sessionId, { limit = 100, offset = 0 } = {}) {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM agent_call_logs WHERE session_id = ?
+      ORDER BY started_at DESC LIMIT ? OFFSET ?`
+      )
+      .all(sessionId, limit, offset);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get aggregated stats for a session, grouped by call_type
+   */
+  getSessionStats(sessionId) {
+    return this.db
+      .prepare(
+        `SELECT
+        call_type,
+        COUNT(*) as call_count,
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        SUM(total_tokens) as total_tokens,
+        AVG(duration_ms) as avg_duration_ms,
+        SUM(duration_ms) as total_duration_ms
+      FROM agent_call_logs
+      WHERE session_id = ?
+      GROUP BY call_type`
+      )
+      .all(sessionId);
+  }
+
+  /**
+   * Get global stats grouped by agent_type within a date range
+   */
+  getGlobalStats(startDate, endDate) {
+    return this.db
+      .prepare(
+        `SELECT
+        agent_type,
+        call_type,
+        COUNT(*) as call_count,
+        SUM(total_tokens) as total_tokens,
+        SUM(input_tokens) as total_input_tokens,
+        SUM(output_tokens) as total_output_tokens,
+        AVG(duration_ms) as avg_duration_ms
+      FROM agent_call_logs
+      WHERE started_at >= ? AND started_at <= ?
+      GROUP BY agent_type, call_type
+      ORDER BY total_tokens DESC`
+      )
+      .all(startDate, endDate);
+  }
+
+  /**
+   * Delete all call logs from the database.
+   * Returns the number of deleted rows.
+   */
+  deleteAll() {
+    const result = this.db.prepare('DELETE FROM agent_call_logs').run();
+    return result.changes;
+  }
+}

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

@@ -0,0 +1,191 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/** Directory name for storing attachments within working directory */
+export const ATTACHMENTS_DIR = '.attachments';
+
+/**
+ * Get the attachments directory path for a session
+ * @param {string} workingDirectory - Project working directory
+ * @param {string} sessionId - Session ID
+ * @returns {string} Path to attachments directory
+ */
+export function getAttachmentsDir(workingDirectory, sessionId) {
+  return join(workingDirectory, ATTACHMENTS_DIR, sessionId);
+}
+
+/**
+ * Attachment repository class for message file attachments
+ */
+export class AttachmentRepository extends BaseRepository {
+  constructor() {
+    super('message_attachments', AttachmentRepository.#mapAttachment);
+  }
+
+  static #mapAttachment(row) {
+    return {
+      id: row.id,
+      messageId: row.message_id,
+      sessionId: row.session_id,
+      filename: row.filename,
+      mimeType: row.mime_type,
+      size: row.size_bytes,
+      storageType: row.storage_type,
+      content: row.content,
+      filePath: row.file_path,
+      createdAt: row.created_at,
+    };
+  }
+
+  /**
+   * Create an attachment - stores in DB and saves to disk
+   * @param {string} sessionId - Session ID
+   * @param {string|null} messageId - Message ID (null for initial session creation)
+   * @param {Object} file - File object with buffer, originalname, mimetype, size
+   * @param {string} workingDirectory - Working directory to save file to
+   * @returns {Object} Created attachment
+   */
+  create(sessionId, messageId, file, workingDirectory) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+
+    // Store as base64 for backwards compatibility
+    const content = file.buffer.toString('base64');
+
+    // Save file to disk if working directory provided
+    let filePath = null;
+    if (workingDirectory) {
+      const attachmentsDir = getAttachmentsDir(workingDirectory, sessionId);
+      mkdirSync(attachmentsDir, { recursive: true });
+
+      // Use ID prefix to ensure uniqueness, preserve original filename for readability
+      const diskFilename = `${id}_${file.originalname}`;
+      filePath = join(attachmentsDir, diskFilename);
+      writeFileSync(filePath, file.buffer);
+    }
+
+    this.db
+      .prepare(
+        `INSERT INTO message_attachments
+         (id, message_id, session_id, filename, mime_type, size_bytes, storage_type, content, file_path, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        messageId,
+        sessionId,
+        file.originalname,
+        file.mimetype,
+        file.size,
+        'base64',
+        content,
+        filePath,
+        now
+      );
+
+    return this.getById(id);
+  }
+
+  /**
+   * Create multiple attachments at once
+   * @param {string} sessionId - Session ID
+   * @param {string|null} messageId - Message ID
+   * @param {Array} files - Array of file objects
+   * @param {string} workingDirectory - Working directory to save files to
+   * @returns {Array} Created attachments
+   */
+  createBatch(sessionId, messageId, files, workingDirectory) {
+    if (!files || files.length === 0) return [];
+    return files.map((file) => this.create(sessionId, messageId, file, workingDirectory));
+  }
+
+  /**
+   * Get attachments by message ID
+   * @param {string} messageId - Message ID
+   * @returns {Array} Attachments for the message
+   */
+  getByMessageId(messageId) {
+    const rows = this.db
+      .prepare('SELECT * FROM message_attachments WHERE message_id = ? ORDER BY created_at ASC')
+      .all(messageId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get attachments by session ID
+   * @param {string} sessionId - Session ID
+   * @returns {Array} Attachments for the session
+   */
+  getBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM message_attachments WHERE session_id = ? ORDER BY created_at ASC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get attachments without content (for listing)
+   * @param {string} messageId - Message ID
+   * @returns {Array} Attachments without content field
+   */
+  getByMessageIdWithoutContent(messageId) {
+    const rows = this.db
+      .prepare(
+        `SELECT id, message_id, session_id, filename, mime_type, size_bytes, storage_type, file_path, created_at
+         FROM message_attachments WHERE message_id = ? ORDER BY created_at ASC`
+      )
+      .all(messageId);
+    return rows.map((row) => ({
+      id: row.id,
+      messageId: row.message_id,
+      sessionId: row.session_id,
+      filename: row.filename,
+      mimeType: row.mime_type,
+      size: row.size_bytes,
+      storageType: row.storage_type,
+      filePath: row.file_path,
+      createdAt: row.created_at,
+    }));
+  }
+
+  /**
+   * Update message ID for attachments (used when associating with a message)
+   * @param {string} sessionId - Session ID
+   * @param {string} messageId - Message ID to set
+   */
+  updateMessageIdForSession(sessionId, messageId) {
+    this.db
+      .prepare('UPDATE message_attachments SET message_id = ? WHERE session_id = ? AND message_id IS NULL')
+      .run(messageId, sessionId);
+  }
+
+  /**
+   * Get pending attachments (those without a message ID)
+   * @param {string} sessionId - Session ID
+   * @returns {Array} Attachments without message ID
+   */
+  getPendingBySessionId(sessionId) {
+    const rows = this.db
+      .prepare(
+        'SELECT * FROM message_attachments WHERE session_id = ? AND message_id IS NULL ORDER BY created_at ASC'
+      )
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Delete all attachments for a session from disk
+   * @param {string} workingDirectory - Working directory
+   * @param {string} sessionId - Session ID
+   */
+  deleteSessionAttachmentsFromDisk(workingDirectory, sessionId) {
+    if (!workingDirectory) return;
+
+    const attachmentsDir = getAttachmentsDir(workingDirectory, sessionId);
+    if (existsSync(attachmentsDir)) {
+      rmSync(attachmentsDir, { recursive: true, force: true });
+    }
+  }
+}

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

@@ -0,0 +1,39 @@
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Base repository class with common CRUD patterns
+ */
+export class BaseRepository {
+  #tableName;
+  #mapFn;
+
+  constructor(tableName, mapFn) {
+    this.#tableName = tableName;
+    this.#mapFn = mapFn;
+  }
+
+  get tableName() {
+    return this.#tableName;
+  }
+
+  get db() {
+    return databaseManager.get();
+  }
+
+  map(row) {
+    return row ? this.#mapFn(row) : null;
+  }
+
+  mapAll(rows) {
+    return rows.map(this.#mapFn);
+  }
+
+  getById(id) {
+    const row = this.db.prepare(`SELECT * FROM ${this.#tableName} WHERE id = ?`).get(id);
+    return this.map(row);
+  }
+
+  delete(id) {
+    this.db.prepare(`DELETE FROM ${this.#tableName} WHERE id = ?`).run(id);
+  }
+}