circuschief 0.1.0

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

@@ -0,0 +1,211 @@
+import { databaseManager } from './DatabaseManager.js';
+import { DEFAULT_TOKEN_COST_WEIGHTS } from '../../../shared/src/index.js';
+
+const TOKEN_WEIGHTS_KEY = 'token_cost_weights';
+const SUMMARY_SETTINGS_KEY = 'summary_settings';
+const GENERAL_SETTINGS_KEY = 'general_settings';
+
+/**
+ * Settings repository for managing application-wide settings
+ */
+export class SettingsRepository {
+  get db() {
+    return databaseManager.get();
+  }
+
+  /**
+   * Get a setting value by key
+   * @param {string} key - Setting key
+   * @returns {string|null} Setting value or null if not found
+   */
+  get(key) {
+    const row = this.db
+      .prepare('SELECT value FROM app_settings WHERE key = ?')
+      .get(key);
+    return row ? row.value : null;
+  }
+
+  /**
+   * Set a setting value
+   * @param {string} key - Setting key
+   * @param {string} value - Setting value (must be string, use JSON.stringify for objects)
+   */
+  set(key, value) {
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO app_settings (key, value, updated_at)
+         VALUES (?, ?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+      )
+      .run(key, value, now);
+  }
+
+  /**
+   * Delete a setting
+   * @param {string} key - Setting key
+   * @returns {boolean} True if deleted, false if not found
+   */
+  delete(key) {
+    const result = this.db
+      .prepare('DELETE FROM app_settings WHERE key = ?')
+      .run(key);
+    return result.changes > 0;
+  }
+
+  /**
+   * Get token cost weights (returns defaults if not set)
+   * @returns {Object} Token cost weights
+   */
+  getTokenCostWeights() {
+    const value = this.get(TOKEN_WEIGHTS_KEY);
+    if (!value) {
+      return { ...DEFAULT_TOKEN_COST_WEIGHTS };
+    }
+    try {
+      const parsed = JSON.parse(value);
+      // Merge with defaults to ensure all keys exist
+      return {
+        input: parsed.input ?? DEFAULT_TOKEN_COST_WEIGHTS.input,
+        output: parsed.output ?? DEFAULT_TOKEN_COST_WEIGHTS.output,
+        cacheRead: parsed.cacheRead ?? DEFAULT_TOKEN_COST_WEIGHTS.cacheRead,
+        cacheCreation: parsed.cacheCreation ?? DEFAULT_TOKEN_COST_WEIGHTS.cacheCreation,
+      };
+    } catch {
+      return { ...DEFAULT_TOKEN_COST_WEIGHTS };
+    }
+  }
+
+  /**
+   * Set token cost weights
+   * @param {Object} weights - Token cost weights
+   * @param {number} weights.input - Input token weight
+   * @param {number} weights.output - Output token weight
+   * @param {number} weights.cacheRead - Cache read token weight
+   * @param {number} weights.cacheCreation - Cache creation token weight
+   */
+  setTokenCostWeights(weights) {
+    // Validate that all weights are positive numbers
+    const validated = {
+      input: Math.max(0, Number(weights.input) || DEFAULT_TOKEN_COST_WEIGHTS.input),
+      output: Math.max(0, Number(weights.output) || DEFAULT_TOKEN_COST_WEIGHTS.output),
+      cacheRead: Math.max(0, Number(weights.cacheRead) || DEFAULT_TOKEN_COST_WEIGHTS.cacheRead),
+      cacheCreation: Math.max(0, Number(weights.cacheCreation) || DEFAULT_TOKEN_COST_WEIGHTS.cacheCreation),
+    };
+    this.set(TOKEN_WEIGHTS_KEY, JSON.stringify(validated));
+    return validated;
+  }
+
+  /**
+   * Reset token cost weights to defaults
+   * @returns {Object} The default weights
+   */
+  resetTokenCostWeights() {
+    this.delete(TOKEN_WEIGHTS_KEY);
+    return { ...DEFAULT_TOKEN_COST_WEIGHTS };
+  }
+
+  // Summary Settings
+
+  /**
+   * Get summary settings with defaults
+   * @returns {Object} Summary settings
+   */
+  getSummarySettings() {
+    const value = this.get(SUMMARY_SETTINGS_KEY);
+    if (!value) {
+      return {
+        disableSessionSummaries: false,
+        sessionTitlePrompt: '',
+      };
+    }
+    try {
+      const parsed = JSON.parse(value);
+      return {
+        disableSessionSummaries: parsed.disableSessionSummaries || false,
+        sessionTitlePrompt: parsed.sessionTitlePrompt || '',
+      };
+    } catch {
+      return {
+        disableSessionSummaries: false,
+        sessionTitlePrompt: '',
+      };
+    }
+  }
+
+  /**
+   * Set summary settings
+   * @param {Object} settings - Summary settings
+   * @param {boolean} settings.disableSessionSummaries - Disable session summaries
+   * @param {string} settings.sessionTitlePrompt - Custom session title prompt
+   */
+  setSummarySettings(settings) {
+    const validated = {
+      disableSessionSummaries: Boolean(settings.disableSessionSummaries),
+      sessionTitlePrompt: String(settings.sessionTitlePrompt || ''),
+    };
+    this.set(SUMMARY_SETTINGS_KEY, JSON.stringify(validated));
+    return validated;
+  }
+
+  /**
+   * Reset summary settings to defaults
+   * @returns {Object} The default settings
+   */
+  resetSummarySettings() {
+    this.delete(SUMMARY_SETTINGS_KEY);
+    return {
+      disableSessionSummaries: false,
+      sessionTitlePrompt: '',
+    };
+  }
+
+  // General Settings
+
+  /**
+   * Get general settings with defaults
+   * @returns {Object} General settings
+   */
+  getGeneralSettings() {
+    const value = this.get(GENERAL_SETTINGS_KEY);
+    if (!value) {
+      return {
+        disableAnalytics: false,
+      };
+    }
+    try {
+      const parsed = JSON.parse(value);
+      return {
+        disableAnalytics: Boolean(parsed.disableAnalytics),
+      };
+    } catch {
+      return {
+        disableAnalytics: false,
+      };
+    }
+  }
+
+  /**
+   * Set general settings
+   * @param {Object} settings - General settings
+   * @param {boolean} settings.disableAnalytics - Disable analytics tracking
+   */
+  setGeneralSettings(settings) {
+    const validated = {
+      disableAnalytics: Boolean(settings.disableAnalytics),
+    };
+    this.set(GENERAL_SETTINGS_KEY, JSON.stringify(validated));
+    return validated;
+  }
+
+  /**
+   * Reset general settings to defaults
+   * @returns {Object} The default settings
+   */
+  resetGeneralSettings() {
+    this.delete(GENERAL_SETTINGS_KEY);
+    return {
+      disableAnalytics: false,
+    };
+  }
+}

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

@@ -0,0 +1,132 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Session todo repository class
+ * Todos are scoped to conversations within sessions
+ */
+export class TodoRepository extends BaseRepository {
+  constructor() {
+    super('session_todos', TodoRepository.#mapTodo);
+  }
+
+  static #mapTodo(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      conversationId: row.conversation_id,
+      content: row.content,
+      status: row.status,
+      position: row.position,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get all todos for a session, ordered by position
+   * @param {string} sessionId
+   * @returns {Array}
+   */
+  getBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM session_todos WHERE session_id = ? ORDER BY position ASC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get all todos for a conversation, ordered by position
+   * @param {string} conversationId
+   * @returns {Array}
+   */
+  getByConversationId(conversationId) {
+    const rows = this.db
+      .prepare('SELECT * FROM session_todos WHERE conversation_id = ? ORDER BY position ASC')
+      .all(conversationId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Replace all todos for a session with a new list
+   * Called when Claude executes TodoWrite
+   * @param {string} sessionId
+   * @param {Array<{content: string, status: string}>} todos
+   * @returns {Array}
+   * @deprecated Use replaceAllForConversation instead
+   */
+  replaceAll(sessionId, todos) {
+    const now = Date.now();
+
+    // Use a transaction for atomicity
+    const transaction = this.db.transaction(() => {
+      // Delete existing todos
+      this.db.prepare('DELETE FROM session_todos WHERE session_id = ?').run(sessionId);
+
+      // Insert new todos
+      const insert = this.db.prepare(
+        `INSERT INTO session_todos (id, session_id, content, status, position, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      );
+
+      for (let i = 0; i < todos.length; i++) {
+        const todo = todos[i];
+        const id = databaseManager.generateId();
+        insert.run(id, sessionId, todo.content, todo.status, i, now);
+      }
+    });
+
+    transaction();
+
+    return this.getBySessionId(sessionId);
+  }
+
+  /**
+   * Replace all todos for a conversation with a new list
+   * Called when Claude executes TodoWrite
+   * @param {string} sessionId
+   * @param {string} conversationId
+   * @param {Array<{content: string, status: string}>} todos
+   * @returns {Array}
+   */
+  replaceAllForConversation(sessionId, conversationId, todos) {
+    const now = Date.now();
+
+    // Use a transaction for atomicity
+    const transaction = this.db.transaction(() => {
+      // Delete existing todos for this conversation
+      this.db.prepare('DELETE FROM session_todos WHERE conversation_id = ?').run(conversationId);
+
+      // Insert new todos
+      const insert = this.db.prepare(
+        `INSERT INTO session_todos (id, session_id, conversation_id, content, status, position, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      );
+
+      for (let i = 0; i < todos.length; i++) {
+        const todo = todos[i];
+        const id = databaseManager.generateId();
+        insert.run(id, sessionId, conversationId, todo.content, todo.status, i, now);
+      }
+    });
+
+    transaction();
+
+    return this.getByConversationId(conversationId);
+  }
+
+  /**
+   * Delete all todos for a session
+   * @param {string} sessionId
+   */
+  deleteBySessionId(sessionId) {
+    this.db.prepare('DELETE FROM session_todos WHERE session_id = ?').run(sessionId);
+  }
+
+  /**
+   * Delete all todos for a conversation
+   * @param {string} conversationId
+   */
+  deleteByConversationId(conversationId) {
+    this.db.prepare('DELETE FROM session_todos WHERE conversation_id = ?').run(conversationId);
+  }
+}

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

@@ -0,0 +1,122 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Work log repository class
+ */
+export class WorkLogRepository extends BaseRepository {
+  constructor() {
+    super('work_logs', WorkLogRepository.#mapWorkLog);
+  }
+
+  static #mapWorkLog(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      messageId: row.message_id,
+      type: row.type,
+      toolName: row.tool_name,
+      content: row.content,
+      timestamp: row.timestamp,
+    };
+  }
+
+  /**
+   * Create a new work log entry
+   * @param {string} sessionId - Session ID
+   * @param {string} type - Log type ('thinking', 'tool_input', 'tool_output')
+   * @param {string} content - Log content
+   * @param {{ messageId?: string|null, toolName?: string|null }} options - Optional parameters
+   * @returns {Object} Created work log
+   */
+  create(sessionId, type, content, options = {}) {
+    const { messageId = null, toolName = null } = options || {};
+
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO work_logs (id, session_id, message_id, type, tool_name, content, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, sessionId, messageId, type, toolName, content, now);
+    return this.getById(id);
+  }
+
+  /**
+   * Get all work logs for a session
+   * @param {string} sessionId - Session ID
+   * @returns {Array} Work logs ordered by timestamp
+   */
+  getBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM work_logs WHERE session_id = ? ORDER BY timestamp ASC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get work logs for a specific message
+   * @param {string} messageId - Message ID
+   * @returns {Array} Work logs for the message
+   */
+  getByMessageId(messageId) {
+    const rows = this.db
+      .prepare('SELECT * FROM work_logs WHERE message_id = ? ORDER BY timestamp ASC')
+      .all(messageId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get work logs grouped by message for a session
+   * @param {string} sessionId - Session ID
+   * @returns {Object} Work logs keyed by message ID
+   */
+  getBySessionIdGrouped(sessionId) {
+    const logs = this.getBySessionId(sessionId);
+    const grouped = {};
+    for (const log of logs) {
+      const key = log.messageId || '_unassociated';
+      if (!grouped[key]) {
+        grouped[key] = [];
+      }
+      grouped[key].push(log);
+    }
+    return grouped;
+  }
+
+  /**
+   * Update the message ID for work logs (used when associating pending logs with a message)
+   * @param {string} sessionId - Session ID
+   * @param {string} messageId - Message ID to associate
+   * @returns {number} Number of work logs that were associated
+   */
+  associatePendingLogs(sessionId, messageId) {
+    const result = this.db
+      .prepare('UPDATE work_logs SET message_id = ? WHERE session_id = ? AND message_id IS NULL')
+      .run(messageId, sessionId);
+    return result.changes;
+  }
+
+  /**
+   * Get recent pending (unassociated) work logs for a session.
+   * These are logs from the current turn that haven't been finalized to a message yet.
+   * @param {string} sessionId - Session ID
+   * @param {number} limit - Maximum number of logs to return (default 15)
+   * @returns {Array} Work logs ordered by timestamp DESC, limited
+   */
+  getRecentPendingBySessionId(sessionId, limit = 15) {
+    const rows = this.db
+      .prepare('SELECT * FROM work_logs WHERE session_id = ? AND message_id IS NULL ORDER BY timestamp DESC LIMIT ?')
+      .all(sessionId, limit);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Delete all work logs for a session
+   * @param {string} sessionId - Session ID
+   */
+  deleteBySessionId(sessionId) {
+    this.db.prepare('DELETE FROM work_logs WHERE session_id = ?').run(sessionId);
+  }
+}

package/packages/server/src/db/conversation-helpers.js

@@ -0,0 +1,119 @@
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Map a raw database row to a conversation object.
+ * @param {Object} row - The raw database row
+ * @returns {Object} The mapped conversation object
+ */
+export function mapConversationRow(row) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    name: row.name,
+    summary: row.summary,
+    summaryGeneratedAt: row.summary_generated_at,
+    isActive: row.is_active === 1,
+    claudeSessionId: row.claude_session_id,
+
+    // Branching fields
+    parentConversationId: row.parent_conversation_id || null,
+    branchFromMessageId: row.branch_from_message_id || null,
+
+    // Token usage fields
+    inputTokens: row.input_tokens || 0,
+    outputTokens: row.output_tokens || 0,
+    cacheReadInputTokens: row.cache_read_input_tokens || 0,
+    cacheCreationInputTokens: row.cache_creation_input_tokens || 0,
+    webSearchRequests: row.web_search_requests || 0,
+    contextWindow: row.context_window || 200000,
+    model: row.model,
+
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+/**
+ * Execute the branch operation: create a new conversation branching from an
+ * existing one at a specific message, copying earlier messages and adding a
+ * new prompt.
+ *
+ * @param {Object} repo - The ConversationRepository instance
+ * @param {string} conversationId - The source conversation ID
+ * @param {string} messageId - The message ID to branch from
+ * @param {Object} options - Branch options
+ * @param {string|null} [options.name] - Optional name for the new conversation
+ * @param {string} options.initialPrompt - The new prompt that replaces the branch point message
+ * @returns {Object} The created branch conversation
+ */
+export function executeBranch(repo, conversationId, messageId, options) {
+  const { name = null, initialPrompt } = options;
+  if (!initialPrompt || !initialPrompt.trim()) {
+    throw new Error('A prompt is required when branching');
+  }
+
+  const sourceConv = repo.getById(conversationId);
+  if (!sourceConv) {
+    throw new Error('Source conversation not found');
+  }
+
+  const branchMessage = repo.db
+    .prepare('SELECT * FROM conversation_messages WHERE id = ? AND conversation_id = ?')
+    .get(messageId, conversationId);
+
+  if (!branchMessage) {
+    throw new Error('Branch point message not found in conversation');
+  }
+
+  const id = databaseManager.generateId();
+  const now = Date.now();
+
+  // Auto-generate name from the prompt (first 40 chars)
+  const promptPreview = initialPrompt.length > 40
+    ? `${initialPrompt.substring(0, 40)}...`
+    : initialPrompt;
+  const branchName = name || promptPreview;
+
+  // Deactivate all other conversations
+  repo.db
+    .prepare('UPDATE conversations SET is_active = 0, updated_at = ? WHERE session_id = ?')
+    .run(now, sourceConv.sessionId);
+
+  // Create the new branch conversation
+  repo.db
+    .prepare(
+      `INSERT INTO conversations (id, session_id, name, is_active, parent_conversation_id, branch_from_message_id, created_at, updated_at)
+       VALUES (?, ?, ?, 1, ?, ?, ?, ?)`
+    )
+    .run(id, sourceConv.sessionId, branchName, conversationId, messageId, now, now);
+
+  // Copy all messages BEFORE the branch point (NOT including it)
+  const messagesToCopy = repo.db
+    .prepare(
+      `SELECT * FROM conversation_messages
+       WHERE conversation_id = ? AND timestamp < ?
+       ORDER BY timestamp ASC`
+    )
+    .all(conversationId, branchMessage.timestamp);
+
+  for (const msg of messagesToCopy) {
+    const newMsgId = databaseManager.generateId();
+    repo.db
+      .prepare(
+        `INSERT INTO conversation_messages (id, session_id, conversation_id, role, content, tool_use, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(newMsgId, sourceConv.sessionId, id, msg.role, msg.content, msg.tool_use, msg.timestamp);
+  }
+
+  // Add the new prompt as the replacement for the original user message
+  const promptMsgId = databaseManager.generateId();
+  repo.db
+    .prepare(
+      `INSERT INTO conversation_messages (id, session_id, conversation_id, role, content, timestamp)
+       VALUES (?, ?, ?, 'user', ?, ?)`
+    )
+    .run(promptMsgId, sourceConv.sessionId, id, initialPrompt.trim(), now);
+
+  return repo.getById(id);
+}

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

@@ -0,0 +1,100 @@
+// Database manager
+export { DatabaseManager, databaseManager } from './DatabaseManager.js';
+
+// Base repository
+export { BaseRepository } from './BaseRepository.js';
+
+// Repository classes
+export { ProjectRepository } from './ProjectRepository.js';
+export { ProjectDefaultsRepository } from './ProjectDefaultsRepository.js';
+export { SessionRepository } from './SessionRepository.js';
+export { SessionTemplateRepository } from './SessionTemplateRepository.js';
+export { MessageRepository } from './MessageRepository.js';
+export { ConversationRepository } from './ConversationRepository.js';
+export { CanvasItemRepository } from './CanvasItemRepository.js';
+export { SessionNoteRepository } from './SessionNoteRepository.js';
+export { TodoRepository } from './TodoRepository.js';
+export { WorkLogRepository } from './WorkLogRepository.js';
+export { SessionSummaryRepository } from './SessionSummaryRepository.js';
+export { AttachmentRepository } from './AttachmentRepository.js';
+export { CommandButtonRepository } from './CommandButtonRepository.js';
+export { CommandRunRepository } from './CommandRunRepository.js';
+export { QuickResponseRepository } from './QuickResponseRepository.js';
+export { SettingsRepository } from './SettingsRepository.js';
+// ProviderRepository replaces ModelProviderRepository; keep the old name exported for any leftover imports
+export { ProviderRepository } from './ProviderRepository.js';
+export { ProviderRepository as ModelProviderRepository } from './ProviderRepository.js';
+export { AgentCallLogRepository } from './AgentCallLogRepository.js';
+export { KanbanBoardRepository } from './KanbanBoardRepository.js';
+export { KanbanLaneRepository } from './KanbanLaneRepository.js';
+export { KanbanCardRepository } from './KanbanCardRepository.js';
+
+// Singleton instances
+import { ProjectRepository } from './ProjectRepository.js';
+import { ProjectDefaultsRepository } from './ProjectDefaultsRepository.js';
+import { MessageRepository } from './MessageRepository.js';
+import { ConversationRepository } from './ConversationRepository.js';
+import { CanvasItemRepository } from './CanvasItemRepository.js';
+import { SessionNoteRepository } from './SessionNoteRepository.js';
+import { TodoRepository } from './TodoRepository.js';
+import { WorkLogRepository } from './WorkLogRepository.js';
+import { SessionSummaryRepository } from './SessionSummaryRepository.js';
+import { SessionTemplateRepository } from './SessionTemplateRepository.js';
+import { AttachmentRepository } from './AttachmentRepository.js';
+import { CommandButtonRepository } from './CommandButtonRepository.js';
+import { CommandRunRepository } from './CommandRunRepository.js';
+import { QuickResponseRepository } from './QuickResponseRepository.js';
+import { SettingsRepository } from './SettingsRepository.js';
+import { ProviderRepository } from './ProviderRepository.js';
+import { AgentCallLogRepository } from './AgentCallLogRepository.js';
+import { KanbanBoardRepository } from './KanbanBoardRepository.js';
+import { KanbanLaneRepository } from './KanbanLaneRepository.js';
+import { KanbanCardRepository } from './KanbanCardRepository.js';
+
+export const projects = new ProjectRepository();
+export const projectDefaults = new ProjectDefaultsRepository();
+export const messages = new MessageRepository();
+export const conversations = new ConversationRepository();
+export const canvasItems = new CanvasItemRepository();
+export const sessionNotes = new SessionNoteRepository();
+export const todos = new TodoRepository();
+export const workLogs = new WorkLogRepository();
+export const sessionSummaries = new SessionSummaryRepository();
+export const sessionTemplates = new SessionTemplateRepository();
+export const attachments = new AttachmentRepository();
+export const commandButtons = new CommandButtonRepository();
+export const commandRuns = new CommandRunRepository();
+export const quickResponses = new QuickResponseRepository();
+export const settings = new SettingsRepository();
+export const modelProviders = new ProviderRepository();
+export const agentCallLogs = new AgentCallLogRepository();
+export const kanbanBoards = new KanbanBoardRepository();
+export const kanbanLanes = new KanbanLaneRepository();
+export const kanbanCards = new KanbanCardRepository();
+
+// SessionRepository needs to be instantiated after messages is available
+import { SessionRepository } from './SessionRepository.js';
+export const sessions = new SessionRepository();
+
+// Legacy function exports for backward compatibility
+import { databaseManager } from './DatabaseManager.js';
+
+export function initDatabase(dbPath) {
+  return databaseManager.init(dbPath);
+}
+
+export function getDatabase() {
+  return databaseManager.get();
+}
+
+export function closeDatabase() {
+  return databaseManager.close();
+}
+
+export function generateId() {
+  return databaseManager.generateId();
+}
+
+export function transaction(fn) {
+  return databaseManager.transaction(fn);
+}