circuschief 0.1.0

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

@@ -0,0 +1,156 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Message repository class
+ */
+export class MessageRepository extends BaseRepository {
+  constructor() {
+    super('conversation_messages', MessageRepository.#mapMessage);
+  }
+
+  static #mapMessage(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      conversationId: row.conversation_id,
+      role: row.role,
+      content: row.content,
+      toolUse: row.tool_use ? JSON.parse(row.tool_use) : null,
+      timestamp: row.timestamp,
+      model: row.model,
+    };
+  }
+
+  /**
+   * Create a new message
+   * @param {string} sessionId - The session ID
+   * @param {string} role - The message role (user, assistant, system)
+   * @param {string} content - The message content
+   * @param {{ toolUse?: Object|null, conversationId?: string|null, model?: string|null }} options - Optional parameters
+   * @returns {Object} The created message
+   */
+  create(sessionId, role, content, options = {}) {
+    const { toolUse = null, conversationId = null, model = null } = options || {};
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO conversation_messages (id, session_id, conversation_id, role, content, tool_use, model, timestamp)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, sessionId, conversationId, role, content, toolUse ? JSON.stringify(toolUse) : null, model, now);
+    return this.getById(id);
+  }
+
+  /**
+   * Get all messages for a session (legacy, returns all messages)
+   * @param {string} sessionId - The session ID
+   * @returns {Array} List of messages
+   */
+  getBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM conversation_messages WHERE session_id = ? ORDER BY timestamp ASC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get messages for a specific conversation
+   * @param {string} conversationId - The conversation ID
+   * @returns {Array} List of messages for the conversation
+   */
+  getByConversationId(conversationId) {
+    const rows = this.db
+      .prepare('SELECT * FROM conversation_messages WHERE conversation_id = ? ORDER BY timestamp ASC')
+      .all(conversationId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get message count for a conversation
+   * @param {string} conversationId - The conversation ID
+   * @returns {number} Number of messages
+   */
+  getCountByConversationId(conversationId) {
+    const result = this.db
+      .prepare('SELECT COUNT(*) as count FROM conversation_messages WHERE conversation_id = ?')
+      .get(conversationId);
+    return result.count;
+  }
+
+  /**
+   * Delete all messages for a conversation
+   * @param {string} conversationId - The conversation ID
+   */
+  deleteByConversationId(conversationId) {
+    this.db
+      .prepare('DELETE FROM conversation_messages WHERE conversation_id = ?')
+      .run(conversationId);
+  }
+
+  /**
+   * Update message content
+   * @param {string} messageId - The message ID
+   * @param {string} content - The new content
+   * @returns {Object} The updated message
+   * @throws {Error} If message not found or content is empty
+   */
+  updateContent(messageId, content) {
+    if (!content || content.trim() === '') {
+      throw new Error('Message content cannot be empty');
+    }
+
+    // Update the message content
+    this.db
+      .prepare(
+        `UPDATE conversation_messages SET content = ? WHERE id = ?`
+      )
+      .run(content, messageId);
+
+    // Return the updated message
+    return this.getById(messageId);
+  }
+
+  /**
+   * Get the most recent assistant message across multiple sessions.
+   * @param {string[]} sessionIds - Array of session IDs to search across
+   * @returns {Object|null} The most recent assistant message, or null if none exist
+   */
+  getLatestAssistantMessageForSessions(sessionIds) {
+    if (!sessionIds || sessionIds.length === 0) return null;
+
+    const placeholders = sessionIds.map(() => '?').join(', ');
+    const row = this.db
+      .prepare(
+        `SELECT * FROM conversation_messages
+         WHERE session_id IN (${placeholders})
+           AND role = 'assistant'
+         ORDER BY timestamp DESC, rowid DESC
+         LIMIT 1`
+      )
+      .get(...sessionIds);
+
+    return row ? this.mapAll([row])[0] : null;
+  }
+
+  /**
+   * Duplicates all messages from source conversations to target conversations.
+   * @param {Map<string, string>} conversationIdMapping - Map of old conversation IDs to new IDs
+   * @param {string} targetSessionId - The new session ID for the messages
+   */
+  duplicateForConversations(conversationIdMapping, targetSessionId) {
+    for (const [sourceConvId, targetConvId] of conversationIdMapping) {
+      const messages = this.getByConversationId(sourceConvId);
+
+      for (const msg of messages) {
+        this.create(
+          targetSessionId,
+          msg.role,
+          msg.content,
+          { toolUse: msg.toolUse, conversationId: targetConvId, model: msg.model }
+        );
+      }
+    }
+  }
+}

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

@@ -0,0 +1,173 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Project session defaults repository class
+ */
+// Maps camelCase data keys to DB column names, with optional boolean conversion
+const UPSERT_FIELD_MAP = [
+  { key: 'mode', column: 'mode' },
+  { key: 'thinkingEnabled', column: 'thinking_enabled', boolean: true },
+  { key: 'startImmediately', column: 'start_immediately', boolean: true },
+  { key: 'gitMode', column: 'git_mode' },
+  { key: 'gitBranch', column: 'git_branch' },
+  { key: 'model', column: 'model' },
+  { key: 'effortLevel', column: 'effort_level' },
+];
+
+/**
+ * Build the update clauses and values for defined fields in data.
+ * @param {Object} data - Input data with optional fields
+ * @returns {{ updates: string[], values: any[] }}
+ */
+function buildUpdateFields(data) {
+  const updates = [];
+  const values = [];
+  for (const { key, column, boolean: isBool } of UPSERT_FIELD_MAP) {
+    if (data[key] !== undefined) {
+      updates.push(`${column} = ?`);
+      values.push(isBool ? (data[key] ? 1 : 0) : data[key]);
+    }
+  }
+  return { updates, values };
+}
+
+export class ProjectDefaultsRepository extends BaseRepository {
+  constructor() {
+    super('project_session_defaults', ProjectDefaultsRepository.#mapDefaults);
+  }
+
+  static #mapDefaults(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      mode: row.mode || null,
+      thinkingEnabled: row.thinking_enabled === null ? null : row.thinking_enabled === 1,
+      startImmediately: row.start_immediately === null ? null : row.start_immediately === 1,
+      gitMode: row.git_mode || null,
+      gitBranch: row.git_branch || null,
+      model: row.model || null,
+      effortLevel: row.effort_level || null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get defaults for a specific project
+   * @param {string} projectId - Project ID
+   * @returns {Object|null} Defaults object or null if not found
+   */
+  getByProjectId(projectId) {
+    const row = this.db
+      .prepare('SELECT * FROM project_session_defaults WHERE project_id = ?')
+      .get(projectId);
+    return row ? ProjectDefaultsRepository.#mapDefaults(row) : null;
+  }
+
+  /**
+   * Create or update defaults for a project (upsert)
+   * Allows partial updates - unspecified fields preserve existing values
+   * @param {string} projectId - Project ID
+   * @param {Object} data - Defaults data (all fields optional)
+   * @returns {Object} Updated defaults object
+   */
+  upsert(projectId, data) {
+    // Get existing defaults if any
+    const existing = this.getByProjectId(projectId);
+
+    if (!existing) {
+      // Create new defaults record
+      const id = databaseManager.generateId();
+      const now = Date.now();
+
+      this.db
+        .prepare(
+          `INSERT INTO project_session_defaults
+           (id, project_id, mode, thinking_enabled, start_immediately, git_mode, git_branch, model, effort_level, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        )
+        .run(
+          id,
+          projectId,
+          data.mode || null,
+          data.thinkingEnabled !== undefined ? (data.thinkingEnabled ? 1 : 0) : null,
+          data.startImmediately !== undefined ? (data.startImmediately ? 1 : 0) : null,
+          data.gitMode || null,
+          data.gitBranch || null,
+          data.model || null,
+          data.effortLevel || null,
+          now,
+          now
+        );
+    } else {
+      // Update existing defaults
+      const { updates, values } = buildUpdateFields(data);
+
+      if (updates.length > 0) {
+        updates.push('updated_at = ?');
+        values.push(Date.now());
+        values.push(projectId);
+
+        this.db
+          .prepare(`UPDATE project_session_defaults SET ${updates.join(', ')} WHERE project_id = ?`)
+          .run(...values);
+      }
+    }
+
+    return this.getByProjectId(projectId);
+  }
+
+  /**
+   * Reset defaults to system defaults (all fields become null)
+   * Returns null if no defaults exist for the project
+   * @param {string} projectId - Project ID
+   * @returns {Object|null} Updated defaults object with all fields set to null, or null if project has no defaults
+   */
+  resetToDefaults(projectId) {
+    const existing = this.getByProjectId(projectId);
+
+    if (!existing) {
+      // Return null for non-existent projects/defaults
+      return null;
+    }
+
+    // Update existing defaults to all nulls
+    this.db
+      .prepare(
+        `UPDATE project_session_defaults
+         SET mode = NULL, thinking_enabled = NULL, start_immediately = NULL,
+             git_mode = NULL, git_branch = NULL, model = NULL, effort_level = NULL, updated_at = ?
+         WHERE project_id = ?`
+      )
+      .run(Date.now(), projectId);
+
+    return this.getByProjectId(projectId);
+  }
+
+  /**
+   * Delete defaults for a project
+   * @param {string} projectId - Project ID
+   */
+  deleteByProjectId(projectId) {
+    this.db
+      .prepare('DELETE FROM project_session_defaults WHERE project_id = ?')
+      .run(projectId);
+  }
+
+  /**
+   * Get system default values
+   * @returns {Object} System defaults object
+   */
+  static getSystemDefaults() {
+    return {
+      mode: 'standard',
+      thinkingEnabled: false,
+      startImmediately: true,
+      gitMode: null,
+      gitBranch: null,
+      model: null,
+      effortLevel: null,
+    };
+  }
+}

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

@@ -0,0 +1,110 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Project repository class
+ */
+export class ProjectRepository extends BaseRepository {
+  constructor() {
+    super('projects', ProjectRepository.#mapProject);
+  }
+
+  static #mapProject(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      workingDirectory: row.working_directory,
+      systemPrompt: row.system_prompt,
+      onSessionCreated: row.on_session_created,
+      onSessionDeleted: row.on_session_deleted,
+      prPollInterval: row.pr_poll_interval,
+      repoUrl: row.repo_url,
+      kanbanEnabled: row.kanban_enabled === undefined ? true : Boolean(row.kanban_enabled),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  create(name, workingDirectory, systemPrompt = null, options = {}) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    const {
+      onSessionCreated = null,
+      onSessionDeleted = null,
+      prPollInterval = 60000,
+      repoUrl = null,
+      kanbanEnabled = true,
+    } = options;
+    this.db
+      .prepare(
+        `INSERT INTO projects (id, name, working_directory, system_prompt, on_session_created, on_session_deleted, pr_poll_interval, repo_url, kanban_enabled, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        name,
+        workingDirectory,
+        systemPrompt,
+        onSessionCreated,
+        onSessionDeleted,
+        prPollInterval,
+        repoUrl,
+        kanbanEnabled ? 1 : 0,
+        now,
+        now
+      );
+    return this.getById(id);
+  }
+
+  getAll() {
+    const rows = this.db.prepare('SELECT * FROM projects ORDER BY updated_at DESC').all();
+    return this.mapAll(rows);
+  }
+
+  update(id, data) {
+    const updates = [];
+    const values = [];
+
+    if (data.name !== undefined) {
+      updates.push('name = ?');
+      values.push(data.name);
+    }
+    if (data.workingDirectory !== undefined) {
+      updates.push('working_directory = ?');
+      values.push(data.workingDirectory);
+    }
+    if (data.systemPrompt !== undefined) {
+      updates.push('system_prompt = ?');
+      values.push(data.systemPrompt);
+    }
+    if (data.onSessionCreated !== undefined) {
+      updates.push('on_session_created = ?');
+      values.push(data.onSessionCreated);
+    }
+    if (data.onSessionDeleted !== undefined) {
+      updates.push('on_session_deleted = ?');
+      values.push(data.onSessionDeleted);
+    }
+    if (data.prPollInterval !== undefined) {
+      updates.push('pr_poll_interval = ?');
+      values.push(data.prPollInterval);
+    }
+    if (data.repoUrl !== undefined) {
+      updates.push('repo_url = ?');
+      values.push(data.repoUrl);
+    }
+    if (data.kanbanEnabled !== undefined) {
+      updates.push('kanban_enabled = ?');
+      values.push(data.kanbanEnabled ? 1 : 0);
+    }
+    if (updates.length === 0) return this.getById(id);
+
+    updates.push('updated_at = ?');
+    values.push(Date.now());
+    values.push(id);
+
+    this.db.prepare(`UPDATE projects SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+
+    return this.getById(id);
+  }
+}