circuschief 0.1.0

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

@@ -0,0 +1,314 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+import { messages, conversations } from './index.js';
+import {
+  ACTIVITY_FIELDS_SQL,
+  mapTokenUsage,
+  mapScheduling,
+  parseCreateConfig,
+  buildUpdateClauses,
+} from './session-helpers.js';
+
+/**
+ * Session repository class
+ */
+export class SessionRepository extends BaseRepository {
+  constructor() {
+    super('sessions', SessionRepository.#mapSession);
+  }
+
+  static #mapSession(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      name: row.name,
+      status: row.status,
+      mode: row.mode,
+      model: row.model,
+      thinkingEnabled: Boolean(row.thinking_enabled),
+      archived: Boolean(row.archived),
+      starred: Boolean(row.starred),
+      manuallyNamed: Boolean(row.manually_named),
+      gitBranch: row.git_branch,
+      gitWorktree: row.git_worktree,
+      prUrl: row.pr_url,
+      error: row.error,
+      costUsd: row.cost_usd,
+      claudeSessionId: row.claude_session_id,
+      nextTemplateId: row.next_template_id,
+      parentSessionId: row.parent_session_id,
+      pendingPrompt: row.pending_prompt || null,
+      pendingModel: row.pending_model || null,
+      effortLevel: row.effort_level || null,
+      autoSendPendingPrompt: Boolean(row.auto_send_pending_prompt),
+      slashCommands: row.slash_commands || null,
+      ...mapTokenUsage(row),
+      ...mapScheduling(row),
+      // Kanban fields
+      targetLaneId: row.target_lane_id || null,
+      laneTriggerDepth: row.lane_trigger_depth || 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      lastActivityAt: row.last_activity_at || row.updated_at || row.created_at,
+      activeTimeMs: row.active_time_ms || 0,
+    };
+  }
+
+  /** Override getById to include computed last_activity_at and active_time_ms fields */
+  getById(id) {
+    const row = this.db
+      .prepare(`SELECT s.*, ${ACTIVITY_FIELDS_SQL} FROM sessions s WHERE s.id = ?`)
+      .get(id);
+    return this.map(row);
+  }
+
+  /** Create a new session with optional config (mode, thinkingEnabled, gitBranch, parentSessionId, status, model, effortLevel) */
+  create(projectId, name, prompt, options = {}) {
+    const config = parseCreateConfig(options, Array.prototype.slice.call(arguments, 4));
+
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO sessions (id, project_id, name, status, mode, thinking_enabled, git_branch, parent_session_id, model, effort_level, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, projectId, name, config.status, config.mode, config.thinkingEnabled ? 1 : 0, config.gitBranch, config.parentSessionId, config.model, config.effortLevel, now, now);
+
+    // Create initial conversation
+    const conversation = conversations.create(id, 'Initial', true);
+
+    // Only create initial user message for sessions that start immediately
+    // For waiting/scheduled sessions, the message will be created when they start
+    if (config.status !== 'waiting' && config.status !== 'scheduled') {
+      messages.create(id, 'user', prompt, { toolUse: null, conversationId: conversation.id });
+    }
+
+    return this.getById(id);
+  }
+
+  getByProjectId(projectId, { archived = null, starred = null, limit = null, offset = 0 } = {}) {
+    let sql = `SELECT s.*, ${ACTIVITY_FIELDS_SQL} FROM sessions s WHERE project_id = ?`;
+    const params = [projectId];
+
+    if (archived !== null) {
+      sql += ` AND archived = ?`;
+      params.push(archived ? 1 : 0);
+    }
+
+    if (starred !== null) {
+      sql += ` AND starred = ?`;
+      params.push(starred ? 1 : 0);
+    }
+
+    sql += ` ORDER BY
+      starred DESC,
+      updated_at DESC,
+      created_at DESC,
+      rowid DESC`;
+
+    // Add LIMIT/OFFSET for pagination
+    if (limit !== null) {
+      sql += ` LIMIT ? OFFSET ?`;
+      params.push(limit, offset);
+    }
+
+    const rows = this.db.prepare(sql).all(...params);
+    return this.mapAll(rows);
+  }
+
+  /** Get count of sessions for a project with optional archived/starred filters */
+  getCountByProjectId(projectId, { archived = null, starred = null } = {}) {
+    let sql = `SELECT COUNT(*) as count FROM sessions WHERE project_id = ?`;
+    const params = [projectId];
+
+    if (archived !== null) {
+      sql += ` AND archived = ?`;
+      params.push(archived ? 1 : 0);
+    }
+
+    if (starred !== null) {
+      sql += ` AND starred = ?`;
+      params.push(starred ? 1 : 0);
+    }
+
+    return this.db.prepare(sql).get(...params).count;
+  }
+
+  getActiveAndWaiting() {
+    const rows = this.db
+      .prepare(
+        `SELECT s.*, p.name as project_name, p.working_directory as project_working_directory, ${ACTIVITY_FIELDS_SQL}
+         FROM sessions s JOIN projects p ON s.project_id = p.id
+         WHERE s.status IN ('starting', 'running', 'waiting') AND s.archived = 0
+         ORDER BY s.starred DESC, s.updated_at DESC, s.created_at DESC, s.rowid DESC`
+      )
+      .all();
+    return rows.map(row => ({
+      ...SessionRepository.#mapSession(row),
+      projectName: row.project_name,
+      projectWorkingDirectory: row.project_working_directory,
+    }));
+  }
+
+  /** Get all child sessions of a parent session */
+  getChildSessions(parentSessionId) {
+    const rows = this.db
+      .prepare(
+        `SELECT s.*, ${ACTIVITY_FIELDS_SQL} FROM sessions s
+         WHERE parent_session_id = ?
+         ORDER BY updated_at DESC, created_at DESC, rowid DESC`
+      )
+      .all(parentSessionId);
+    return this.mapAll(rows);
+  }
+
+  /** Walk the parentSessionId chain upward to find the root session */
+  getRootSessionId(sessionId) {
+    let current = this.getById(sessionId);
+    const visited = new Set();
+
+    while (current?.parentSessionId) {
+      if (visited.has(current.id)) break; // cycle guard
+      visited.add(current.id);
+      current = this.getById(current.parentSessionId);
+    }
+
+    return current?.id ?? null;
+  }
+
+  /** Collect all descendant session IDs recursively (does NOT include the starting session) */
+  getAllDescendantIds(sessionId) {
+    const stmt = this.db.prepare('SELECT id FROM sessions WHERE parent_session_id = ?');
+    const descendantIds = [];
+    const stack = [sessionId];
+    const visited = new Set();
+
+    while (stack.length > 0) {
+      const currentId = stack.pop();
+      if (visited.has(currentId)) continue;
+      visited.add(currentId);
+
+      const childRows = stmt.all(currentId);
+      for (const row of childRows) {
+        descendantIds.push(row.id);
+        stack.push(row.id);
+      }
+    }
+
+    return descendantIds;
+  }
+
+  update(id, data) {
+    const { updates, values } = buildUpdateClauses(data);
+
+    if (updates.length === 0) return this.getById(id);
+
+    updates.push('updated_at = ?');
+    values.push(Date.now());
+    values.push(id);
+
+    this.db.prepare(`UPDATE sessions SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+
+    return this.getById(id);
+  }
+
+  /** Duplicate a session with a new ID and reset state (does NOT handle git or conversation setup) */
+  duplicate(sourceSessionId, { name } = {}) {
+    const source = this.getById(sourceSessionId);
+    if (!source) {
+      throw new Error(`Session not found: ${sourceSessionId}`);
+    }
+
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    const newName = name || `${source.name} (Copy)`;
+
+    // Insert new session with same settings but new ID and status
+    this.db
+      .prepare(
+        `INSERT INTO sessions (id, project_id, name, status, mode, thinking_enabled, git_branch, model, effort_level, context_window,
+                               input_tokens, output_tokens, cache_read_input_tokens, cache_creation_input_tokens,
+                               web_search_requests, cost_usd, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        source.projectId,
+        newName,
+        'waiting',  // Always reset status to draft
+        source.mode,
+        source.thinkingEnabled ? 1 : 0,
+        source.gitBranch,  // Copy branch name (NOT worktree path)
+        source.model,
+        source.effortLevel,
+        source.contextWindow,
+        source.inputTokens,
+        source.outputTokens,
+        source.cacheReadInputTokens,
+        source.cacheCreationInputTokens,
+        source.webSearchRequests,
+        source.costUsd,
+        now,
+        now
+      );
+
+    return this.getById(id);
+  }
+
+  /** Get all sessions that have a PR URL set (used by prStatusService) */
+  getSessionsWithPrUrls() {
+    const rows = this.db
+      .prepare(
+        `SELECT s.*, ${ACTIVITY_FIELDS_SQL} FROM sessions s
+         WHERE pr_url IS NOT NULL ORDER BY updated_at DESC, created_at DESC, rowid DESC`
+      )
+      .all();
+    return this.mapAll(rows);
+  }
+
+  updateUsage(id, usage) {
+    this.db
+      .prepare(
+        `UPDATE sessions SET input_tokens = ?, output_tokens = ?, cache_read_input_tokens = ?,
+          cache_creation_input_tokens = ?, web_search_requests = ?, context_window = ?, updated_at = ?
+        WHERE id = ?`
+      )
+      .run(usage.inputTokens, usage.outputTokens, usage.cacheReadInputTokens,
+        usage.cacheCreationInputTokens, usage.webSearchRequests, usage.contextWindow, Date.now(), id);
+    return this.getById(id);
+  }
+
+  /** Get scheduled sessions that are due to start (scheduled_at <= now) */
+  getScheduledSessionsDue(now) {
+    const rows = this.db
+      .prepare(
+        `SELECT s.*, ${ACTIVITY_FIELDS_SQL} FROM sessions s
+         WHERE status = 'scheduled' AND scheduled_at IS NOT NULL AND scheduled_at <= ? AND archived = 0
+         ORDER BY scheduled_at ASC`
+      )
+      .all(now);
+    return this.mapAll(rows);
+  }
+
+  /** Get all scheduled sessions, optionally filtered by project */
+  getScheduledSessions(projectId = null) {
+    let sql = `SELECT s.*, p.name as project_name, ${ACTIVITY_FIELDS_SQL}
+      FROM sessions s JOIN projects p ON s.project_id = p.id
+      WHERE s.status = 'scheduled' AND s.archived = 0`;
+    const params = [];
+
+    if (projectId) {
+      sql += ` AND s.project_id = ?`;
+      params.push(projectId);
+    }
+
+    sql += ` ORDER BY s.scheduled_at ASC`;
+
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map(row => ({
+      ...SessionRepository.#mapSession(row),
+      projectName: row.project_name,
+    }));
+  }
+}

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

@@ -0,0 +1,200 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Field definitions for session summary updates.
+ * Each entry defines how to transform the value for SQL.
+ */
+const SUMMARY_FIELDS = {
+  shortSummary: { column: 'short_summary', transform: (v) => v },
+  fullSummary: { column: 'full_summary', transform: (v) => v },
+  keyActions: { column: 'key_actions', transform: (v) => JSON.stringify(v) },
+  filesModified: { column: 'files_modified', transform: (v) => JSON.stringify(v) },
+  outcome: { column: 'outcome', transform: (v) => v },
+  messageCount: { column: 'message_count', transform: (v) => v },
+  lastSummarizedMessageId: { column: 'last_summarized_message_id', transform: (v) => v },
+  prMerged: { column: 'pr_merged', transform: (v) => (v ? 1 : 0) },
+  prState: { column: 'pr_state', transform: (v) => v },
+  hasMergeConflicts: { column: 'has_merge_conflicts', transform: (v) => (v ? 1 : 0) },
+  ciStatus: { column: 'ci_status', transform: (v) => v },
+  ciFailures: { column: 'ci_failures', transform: (v) => JSON.stringify(v) },
+};
+
+/**
+ * Convert an optional boolean to a DB-compatible value (null, 0, or 1).
+ */
+function optionalBoolToDb(value) {
+  if (value === undefined) return null;
+  return value ? 1 : 0;
+}
+
+/**
+ * Session summary repository class
+ */
+export class SessionSummaryRepository extends BaseRepository {
+  constructor() {
+    super('session_summaries', SessionSummaryRepository.#mapSummary);
+  }
+
+  static #mapSummary(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      shortSummary: row.short_summary,
+      fullSummary: row.full_summary,
+      keyActions: row.key_actions ? JSON.parse(row.key_actions) : [],
+      filesModified: row.files_modified ? JSON.parse(row.files_modified) : [],
+      outcome: row.outcome,
+      messageCount: row.message_count,
+      lastSummarizedMessageId: row.last_summarized_message_id,
+      prMerged: row.pr_merged !== null ? Boolean(row.pr_merged) : null,
+      prState: row.pr_state,
+      hasMergeConflicts: row.has_merge_conflicts !== null ? Boolean(row.has_merge_conflicts) : null,
+      ciStatus: row.ci_status,
+      ciFailures: row.ci_failures ? JSON.parse(row.ci_failures) : [],
+      generatedAt: row.generated_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Get summary by session ID
+   * @param {string} sessionId
+   * @returns {Object|null}
+   */
+  getBySessionId(sessionId) {
+    const row = this.db
+      .prepare('SELECT * FROM session_summaries WHERE session_id = ?')
+      .get(sessionId);
+    return this.map(row);
+  }
+
+  /**
+   * Create a new session summary
+   * @param {string} sessionId
+   * @param {Object} data
+   * @returns {Object}
+   */
+  create(sessionId, data) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO session_summaries
+         (id, session_id, short_summary, full_summary, key_actions, files_modified, outcome, message_count, last_summarized_message_id, pr_merged, pr_state, has_merge_conflicts, ci_status, ci_failures, generated_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        sessionId,
+        data.shortSummary,
+        data.fullSummary,
+        data.keyActions ? JSON.stringify(data.keyActions) : null,
+        data.filesModified ? JSON.stringify(data.filesModified) : null,
+        data.outcome || 'ongoing',
+        data.messageCount || 0,
+        data.lastSummarizedMessageId || null,
+        optionalBoolToDb(data.prMerged),
+        data.prState || null,
+        optionalBoolToDb(data.hasMergeConflicts),
+        data.ciStatus || null,
+        data.ciFailures ? JSON.stringify(data.ciFailures) : null,
+        now,
+        now,
+        now
+      );
+    return this.getById(id);
+  }
+
+  /**
+   * Update an existing session summary
+   * @param {string} id
+   * @param {Object} data
+   * @returns {Object}
+   */
+  update(id, data) {
+    const updates = [];
+    const values = [];
+
+    // Build update clauses from field definitions
+    for (const [key, def] of Object.entries(SUMMARY_FIELDS)) {
+      if (data[key] !== undefined) {
+        updates.push(`${def.column} = ?`);
+        values.push(def.transform(data[key]));
+      }
+    }
+
+    if (updates.length === 0) return this.getById(id);
+
+    // Always update generated_at and updated_at when updating
+    const now = Date.now();
+    updates.push('generated_at = ?', 'updated_at = ?');
+    values.push(now, now, id);
+
+    this.db.prepare(`UPDATE session_summaries SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+
+    return this.getById(id);
+  }
+
+  /**
+   * Create or update a session summary (upsert)
+   * @param {string} sessionId
+   * @param {Object} data
+   * @returns {Object}
+   */
+  upsert(sessionId, data) {
+    const existing = this.getBySessionId(sessionId);
+    if (existing) {
+      return this.update(existing.id, data);
+    }
+    return this.create(sessionId, data);
+  }
+
+  /**
+   * Get summaries for multiple session IDs in a single query
+   * @param {string[]} sessionIds
+   * @returns {Object[]}
+   */
+  getBySessionIds(sessionIds) {
+    if (!sessionIds || sessionIds.length === 0) return [];
+    const placeholders = sessionIds.map(() => '?').join(',');
+    const rows = this.db
+      .prepare(`SELECT * FROM session_summaries WHERE session_id IN (${placeholders})`)
+      .all(...sessionIds);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Delete summary by session ID
+   * @param {string} sessionId
+   */
+  deleteBySessionId(sessionId) {
+    this.db.prepare('DELETE FROM session_summaries WHERE session_id = ?').run(sessionId);
+  }
+
+  /**
+   * Duplicates the session summary from one session to another.
+   * Note: PR-related fields (prMerged, prState, hasMergeConflicts, ciStatus, ciFailures)
+   * are NOT copied because the duplicated session is a fresh start and may create
+   * its own PR. Copying prMerged=true would prevent the summary from ever being
+   * regenerated (see summaryService.generateSummary skip logic).
+   * @param {string} sourceSessionId - Source session ID
+   * @param {string} targetSessionId - Target session ID
+   */
+  duplicateForSession(sourceSessionId, targetSessionId) {
+    const summary = this.getBySessionId(sourceSessionId);
+
+    if (summary) {
+      this.create(targetSessionId, {
+        shortSummary: summary.shortSummary,
+        fullSummary: summary.fullSummary,
+        keyActions: summary.keyActions,
+        filesModified: summary.filesModified,
+        outcome: summary.outcome,
+        messageCount: summary.messageCount,
+        // PR-related fields intentionally omitted - see note above
+      });
+    }
+  }
+}

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

@@ -0,0 +1,171 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Session template repository class
+ */
+export class SessionTemplateRepository extends BaseRepository {
+  constructor() {
+    super('session_templates', SessionTemplateRepository.#mapTemplate);
+  }
+
+  static #mapTemplate(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      name: row.name,
+      prompt: row.prompt,
+      nextTemplateId: row.next_template_id,
+      thinkingEnabled: row.thinking_enabled === null ? null : Boolean(row.thinking_enabled),
+      gitBranch: row.git_branch,
+      gitMode: row.git_mode,
+      model: row.model || null,
+      mode: row.mode || null,
+      effortLevel: row.effort_level ?? null,
+      targetLaneId: row.target_lane_id || null,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  /**
+   * Create a new session template
+   * @param {Object} data
+   * @param {string|null} data.projectId - null for global templates
+   * @param {string} data.name
+   * @param {string} data.prompt
+   * @param {string|null} data.nextTemplateId
+   * @param {boolean|null} data.thinkingEnabled
+   * @param {string|null} data.gitBranch
+   * @param {string|null} data.gitMode
+   * @param {string|null} data.model
+   * @param {string|null} data.mode
+   * @param {string|null} data.effortLevel
+   * @returns {Object}
+   */
+  /**
+   * Normalize thinkingEnabled to a DB-compatible value (null, 0, or 1).
+   */
+  static #normalizeThinkingEnabled(value) {
+    if (value === null || value === undefined) return null;
+    return value ? 1 : 0;
+  }
+
+  create(data) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO session_templates (id, project_id, name, prompt, next_template_id, thinking_enabled, git_branch, git_mode, model, mode, effort_level, target_lane_id, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        data.projectId || null,
+        data.name,
+        data.prompt,
+        data.nextTemplateId || null,
+        SessionTemplateRepository.#normalizeThinkingEnabled(data.thinkingEnabled),
+        data.gitBranch || null,
+        data.gitMode || null,
+        data.model || null,
+        data.mode !== undefined && data.mode !== null ? data.mode : null,
+        data.effortLevel ?? null,
+        data.targetLaneId || null,
+        now,
+        now
+      );
+    return this.getById(id);
+  }
+
+  /**
+   * Field mapping for update: property name -> { column, transform }
+   * Transform converts the JS value to the DB value.
+   */
+  static #updateFields = {
+    name: { column: 'name', transform: (v) => v },
+    prompt: { column: 'prompt', transform: (v) => v },
+    nextTemplateId: { column: 'next_template_id', transform: (v) => v },
+    thinkingEnabled: { column: 'thinking_enabled', transform: (v) => (v === null ? null : (v ? 1 : 0)) },
+    gitBranch: { column: 'git_branch', transform: (v) => v || null },  // Match create() behavior: empty string -> null
+    gitMode: { column: 'git_mode', transform: (v) => v },
+    model: { column: 'model', transform: (v) => v },
+    mode: { column: 'mode', transform: (v) => v },
+    effortLevel: { column: 'effort_level', transform: (v) => v },
+    targetLaneId: { column: 'target_lane_id', transform: (v) => v },
+  };
+
+  /**
+   * Update a session template
+   * @param {string} id
+   * @param {Object} data
+   * @returns {Object}
+   */
+  update(id, data) {
+    const updates = [];
+    const values = [];
+
+    for (const [key, def] of Object.entries(SessionTemplateRepository.#updateFields)) {
+      if (data[key] !== undefined) {
+        updates.push(`${def.column} = ?`);
+        values.push(def.transform(data[key]));
+      }
+    }
+
+    if (updates.length === 0) return this.getById(id);
+
+    updates.push('updated_at = ?');
+    values.push(Date.now());
+    values.push(id);
+
+    this.db.prepare(`UPDATE session_templates SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+
+    return this.getById(id);
+  }
+
+  /**
+   * Get all global templates (projectId is null)
+   * @returns {Array}
+   */
+  getGlobal() {
+    const rows = this.db
+      .prepare('SELECT * FROM session_templates WHERE project_id IS NULL ORDER BY name')
+      .all();
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get templates by project ID
+   * @param {string} projectId
+   * @returns {Array}
+   */
+  getByProjectId(projectId) {
+    const rows = this.db
+      .prepare('SELECT * FROM session_templates WHERE project_id = ? ORDER BY name')
+      .all(projectId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get all templates available for a project (project-specific + global)
+   * @param {string} projectId
+   * @returns {Object} { project: Array, global: Array }
+   */
+  getAvailableForProject(projectId) {
+    return {
+      project: this.getByProjectId(projectId),
+      global: this.getGlobal(),
+    };
+  }
+
+  /**
+   * Get all templates
+   * @returns {Array}
+   */
+  getAll() {
+    const rows = this.db
+      .prepare('SELECT * FROM session_templates ORDER BY project_id NULLS FIRST, name')
+      .all();
+    return this.mapAll(rows);
+  }
+}