circuschief 0.8.0 → 1.1.0

package/packages/server/src/db/migrations/projectsMigrations.js

@@ -0,0 +1,130 @@
+/**
+ * Migrations for the projects table and project-related tables.
+ * Each export is an array of { name, up(db) } migration objects.
+ */
+import { addColumnIfMissing, getColumns, tableExists } from './migrationUtils.js';
+
+/**
+ * Drop legacy project-level summary columns from the projects table.
+ * These settings have been consolidated under global settings (SettingsRepository).
+ */
+function migrateProjectsDropSummaryColumns(db) {
+  const columns = getColumns(db, 'projects');
+
+  const columnsToRemove = [
+    'disable_session_summaries',
+    'disable_conversation_summaries',
+    'summary_debounce_ms',
+    'session_title_prompt',
+  ];
+
+  for (const col of columnsToRemove) {
+    if (columns.includes(col)) {
+      db.exec(`ALTER TABLE projects DROP COLUMN ${col}`);
+    }
+  }
+}
+
+/** @type {Array<{name: string, up: (db: import('better-sqlite3').Database) => void}>} */
+export const projectsMigrations = [
+  {
+    name: 'projects-add-system_prompt',
+    up(db) { addColumnIfMissing(db, 'projects', 'system_prompt', 'TEXT'); },
+  },
+  {
+    name: 'projects-add-on_session_created',
+    up(db) { addColumnIfMissing(db, 'projects', 'on_session_created', 'TEXT'); },
+  },
+  {
+    name: 'projects-add-on_session_deleted',
+    up(db) { addColumnIfMissing(db, 'projects', 'on_session_deleted', 'TEXT'); },
+  },
+  {
+    name: 'projects-add-repo_url',
+    up(db) { addColumnIfMissing(db, 'projects', 'repo_url', 'TEXT'); },
+  },
+  {
+    name: 'projects-add-worktree_path',
+    up(db) { addColumnIfMissing(db, 'projects', 'worktree_path', 'TEXT'); },
+  },
+  {
+    name: 'projects-drop-summary-columns',
+    up(db) { migrateProjectsDropSummaryColumns(db); },
+  },
+
+  // --- Project session defaults table ---
+  {
+    name: 'project_session_defaults-create-table',
+    up(db) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS project_session_defaults (
+          id TEXT PRIMARY KEY,
+          project_id TEXT NOT NULL UNIQUE,
+          mode TEXT CHECK(mode IN ('plan', 'standard', 'yolo')),
+          thinking_enabled INTEGER,
+          start_immediately INTEGER,
+          git_mode TEXT CHECK(git_mode IN ('branch', 'worktree')),
+          git_branch TEXT,
+          model TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_project_defaults_projectId ON project_session_defaults(project_id);
+      `);
+    },
+  },
+  {
+    name: 'project_session_defaults-add-provider_id',
+    up(db) {
+      if (tableExists(db, 'project_session_defaults')) {
+        addColumnIfMissing(
+          db, 'project_session_defaults', 'provider_id',
+          'TEXT REFERENCES providers(id)'
+        );
+      }
+    },
+  },
+  {
+    name: 'project_session_defaults-add-effort_level',
+    up(db) {
+      if (tableExists(db, 'project_session_defaults')) {
+        addColumnIfMissing(
+          db, 'project_session_defaults', 'effort_level',
+          "TEXT CHECK(effort_level IN ('low', 'medium', 'high', 'max', 'auto'))"
+        );
+      }
+    },
+  },
+  {
+    name: 'project_session_defaults-git_mode-add-current',
+    up(db) {
+      if (!tableExists(db, 'project_session_defaults')) return;
+      // SQLite doesn't support ALTER TABLE ... ALTER CONSTRAINT, so we recreate the table
+      db.exec(`
+        CREATE TABLE project_session_defaults_new (
+          id TEXT PRIMARY KEY,
+          project_id TEXT NOT NULL UNIQUE,
+          mode TEXT CHECK(mode IN ('plan', 'standard', 'yolo')),
+          thinking_enabled INTEGER,
+          start_immediately INTEGER,
+          git_mode TEXT CHECK(git_mode IN ('branch', 'worktree', 'current')),
+          git_branch TEXT,
+          model TEXT,
+          provider_id TEXT REFERENCES providers(id),
+          effort_level TEXT CHECK(effort_level IN ('low', 'medium', 'high', 'max', 'auto')),
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+        );
+        INSERT INTO project_session_defaults_new
+          SELECT id, project_id, mode, thinking_enabled, start_immediately, git_mode,
+                 git_branch, model, provider_id, effort_level, created_at, updated_at
+          FROM project_session_defaults;
+        DROP TABLE project_session_defaults;
+        ALTER TABLE project_session_defaults_new RENAME TO project_session_defaults;
+        CREATE INDEX IF NOT EXISTS idx_project_defaults_projectId ON project_session_defaults(project_id);
+      `);
+    },
+  },
+];

package/packages/server/src/db/migrations/providerCommitAttributionMigrations.js

@@ -0,0 +1,30 @@
+import { normalizeCommitAttributionOverride } from '../../../../shared/src/contracts/providers.js';
+import { tableExists } from './migrationUtils.js';
+
+function normalizeProviderCommitAttributionOverrides(db) {
+  if (!tableExists(db, 'providers')) return;
+  const rows = db
+    .prepare('SELECT id, commit_attribution_override FROM providers WHERE commit_attribution_override IS NOT NULL')
+    .all();
+  const update = db.prepare('UPDATE providers SET commit_attribution_override = ? WHERE id = ?');
+
+  for (const row of rows) {
+    try {
+      const normalized = normalizeCommitAttributionOverride(row.commit_attribution_override);
+      if (normalized !== row.commit_attribution_override) {
+        update.run(normalized, row.id);
+      }
+    } catch {
+      // Irrecoverable legacy values, such as bare emails, are preserved until edited.
+    }
+  }
+}
+
+export const providerCommitAttributionMigrations = [
+  {
+    name: 'providers-normalize-commit_attribution_override',
+    up(db) {
+      normalizeProviderCommitAttributionOverrides(db);
+    },
+  },
+];

package/packages/server/src/db/migrations/providerMigrations.js

@@ -0,0 +1,250 @@
+import { OPENAI_MODELS, GEMINI_MODELS } from '../../../../shared/src/index.js';
+import { addColumnIfMissing, tableExists } from './migrationUtils.js';
+
+function seedBuiltInAnthropicProvider(db) {
+  const providerId = 'anthropic-default';
+  const existing = db
+    .prepare('SELECT id FROM providers WHERE id = ?')
+    .get(providerId);
+
+  if (!existing) {
+    const now = Date.now();
+    db.prepare(
+      `INSERT INTO providers (id, name, is_built_in, created_at, updated_at)
+       VALUES (?, ?, 1, ?, ?)`
+    ).run(providerId, 'Anthropic (Official)', now, now);
+  }
+
+  const defaultModels = [
+    { id: 'anthropic-haiku', modelId: 'claude-haiku-4-5-20251001', displayName: 'Haiku 4.5', description: 'Fast & lightweight', tier: 'haiku' },
+    { id: 'anthropic-sonnet', modelId: 'claude-sonnet-4-6', displayName: 'Sonnet 4.6', description: 'Balanced', tier: 'sonnet' },
+    { id: 'anthropic-opus', modelId: 'claude-opus-4-6', displayName: 'Opus 4.6', description: 'Previous generation', tier: 'opus' },
+    { id: 'anthropic-opus-4-7', modelId: 'claude-opus-4-7', displayName: 'Opus 4.7', description: 'Most capable (default)', tier: 'opus' },
+  ];
+
+  const insertModel = db.prepare(
+    `INSERT OR IGNORE INTO provider_models (id, provider_id, model_id, display_name, description, tier, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+
+  const now = Date.now();
+  for (const model of defaultModels) {
+    insertModel.run(model.id, providerId, model.modelId, model.displayName, model.description, model.tier, now);
+  }
+}
+
+function seedBuiltInOpenAIProvider(db) {
+  const providerId = 'openai-default';
+  const now = Date.now();
+
+  db.prepare(
+    `INSERT OR IGNORE INTO providers (
+       id, name, base_url, auth_token, kind, is_built_in, created_at, updated_at
+     )
+     VALUES (?, ?, NULL, NULL, 'openai', 1, ?, ?)`
+  ).run(providerId, 'OpenAI (Official)', now, now);
+
+  const insertModel = db.prepare(
+    `INSERT OR IGNORE INTO provider_models (id, provider_id, model_id, display_name, description, tier, created_at)
+     VALUES (?, ?, ?, ?, ?, 'custom', ?)`
+  );
+
+  for (const model of OPENAI_MODELS) {
+    insertModel.run(model.seedId, providerId, model.id, model.name, model.description, now);
+  }
+}
+
+function seedBuiltInGoogleProvider(db) {
+  const providerId = 'google-default';
+  const now = Date.now();
+
+  db.prepare(
+    `INSERT OR IGNORE INTO providers (
+       id, name, base_url, auth_token, kind, is_built_in, created_at, updated_at
+     )
+     VALUES (?, ?, NULL, NULL, 'google', 1, ?, ?)`
+  ).run(providerId, 'Google (Official)', now, now);
+
+  const insertModel = db.prepare(
+    `INSERT OR IGNORE INTO provider_models (id, provider_id, model_id, display_name, description, tier, created_at)
+     VALUES (?, ?, ?, ?, ?, 'custom', ?)`
+  );
+
+  for (const model of GEMINI_MODELS) {
+    insertModel.run(model.seedId, providerId, model.id, model.name, model.description, now);
+  }
+}
+
+function seedBuiltInProviders(db) {
+  seedBuiltInAnthropicProvider(db);
+  seedBuiltInOpenAIProvider(db);
+}
+
+function updateBuiltInModels(db) {
+  const providerId = 'anthropic-default';
+
+  db.prepare(
+    `UPDATE provider_models
+     SET model_id = ?, display_name = ?
+     WHERE provider_id = ? AND id = ?`
+  ).run('claude-sonnet-4-6', 'Sonnet 4.6', providerId, 'anthropic-sonnet');
+
+  db.prepare(
+    `UPDATE provider_models
+     SET model_id = ?, display_name = ?
+     WHERE provider_id = ? AND id = ?`
+  ).run('claude-opus-4-6', 'Opus 4.6', providerId, 'anthropic-opus');
+}
+
+export const providerMigrations = [
+  {
+    name: 'model_providers-cleanup-legacy',
+    up(db) {
+      if (tableExists(db, 'model_providers')) {
+        db.exec('DROP TABLE IF EXISTS provider_models');
+        db.exec('DROP TABLE IF EXISTS model_providers');
+      }
+    },
+  },
+  {
+    name: 'providers-create-tables',
+    up(db) {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS providers (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          base_url TEXT,
+          auth_token TEXT,
+          api_timeout_ms INTEGER,
+          additional_env_vars TEXT,
+          commit_attribution_override TEXT,
+          is_built_in INTEGER NOT NULL DEFAULT 0,
+          kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google')),
+          created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+          updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+        );
+
+        CREATE TABLE IF NOT EXISTS provider_models (
+          id TEXT PRIMARY KEY,
+          provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+          model_id TEXT NOT NULL,
+          display_name TEXT NOT NULL,
+          description TEXT,
+          tier TEXT CHECK(tier IN ('opus', 'sonnet', 'haiku', 'custom')),
+          created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+        );
+        CREATE INDEX IF NOT EXISTS idx_provider_models_provider ON provider_models(provider_id);
+      `);
+    },
+  },
+  {
+    name: 'providers-add-kind',
+    up(db) {
+      addColumnIfMissing(
+        db,
+        'providers',
+        'kind',
+        "TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google'))"
+      );
+    },
+  },
+  {
+    name: 'providers-add-commit_attribution_override',
+    up(db) {
+      addColumnIfMissing(db, 'providers', 'commit_attribution_override', 'TEXT');
+    },
+  },
+  {
+    name: 'providers-seed-built-in',
+    up(db) { seedBuiltInProviders(db); },
+  },
+  {
+    name: 'providers-seed-built-in-openai',
+    up(db) { seedBuiltInOpenAIProvider(db); },
+  },
+  {
+    name: 'providers-update-built-in-models',
+    up(db) { updateBuiltInModels(db); },
+  },
+  {
+    name: 'providers-update-built-in-opus-4-7',
+    up(db) {
+      const providerId = 'anthropic-default';
+
+      db.prepare(
+        `UPDATE provider_models
+         SET description = ?
+         WHERE provider_id = ? AND id = ?`
+      ).run('Previous generation', providerId, 'anthropic-opus');
+
+      db.prepare(
+        `INSERT OR IGNORE INTO provider_models (id, provider_id, model_id, display_name, description, tier, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      ).run('anthropic-opus-4-7', providerId, 'claude-opus-4-7', 'Opus 4.7', 'Most capable (default)', 'opus', Date.now());
+    },
+  },
+  {
+    name: 'providers-widen-kind-check-google',
+    up(db) {
+      // SQLite CHECK constraints are baked into the table definition and can't
+      // be altered in-place. Recreate the table with the wider CHECK.
+      //
+      // IMPORTANT: Disable foreign key enforcement during the table swap.
+      // provider_models has ON DELETE CASCADE referencing providers. SQLite
+      // fires that cascade when DROP TABLE deletes parent rows, which would
+      // wipe all provider_models data. Disabling FK enforcement prevents the
+      // cascade. We re-enable it immediately after the rename.
+      db.pragma('foreign_keys = OFF');
+      try {
+        db.exec(`
+          CREATE TABLE IF NOT EXISTS providers_new (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            base_url TEXT,
+            auth_token TEXT,
+            api_timeout_ms INTEGER,
+            additional_env_vars TEXT,
+            commit_attribution_override TEXT,
+            is_built_in INTEGER NOT NULL DEFAULT 0,
+            kind TEXT NOT NULL DEFAULT 'anthropic' CHECK(kind IN ('anthropic','openai','google')),
+            created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+            updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+          );
+
+          INSERT OR IGNORE INTO providers_new SELECT * FROM providers;
+
+          DROP TABLE providers;
+
+          ALTER TABLE providers_new RENAME TO providers;
+
+          CREATE INDEX IF NOT EXISTS idx_provider_models_provider ON provider_models(provider_id);
+        `);
+      } finally {
+        db.pragma('foreign_keys = ON');
+      }
+    },
+  },
+  {
+    name: 'providers-seed-built-in-google',
+    up(db) { seedBuiltInGoogleProvider(db); },
+  },
+  {
+    name: 'providers-update-gemini-flash-lite-model',
+    up(db) {
+      // The preview model 'gemini-2.5-flash-lite-preview-06-17' has been
+      // removed by Google. Update to the stable GA model ID.
+      db.prepare(
+        `UPDATE provider_models
+         SET model_id = ?, description = ?
+         WHERE id = ? AND provider_id = ?`
+      ).run('gemini-2.5-flash-lite', 'Lightweight & cost-efficient', 'google-gemini-2-5-flash-lite', 'google-default');
+
+      // Also update any sessions that were using the old model ID
+      db.prepare(
+        `UPDATE sessions
+         SET model = ?
+         WHERE model = ?`
+      ).run('gemini-2.5-flash-lite', 'gemini-2.5-flash-lite-preview-06-17');
+    },
+  },
+];

package/packages/server/src/db/migrations/sessionTableRecreate.js

@@ -0,0 +1,136 @@
+/**
+ * Helper for recreating the sessions table during migrations that change
+ * column defaults or constraints (SQLite requires table recreation for these).
+ */
+import { getColumns } from './migrationUtils.js';
+
+const TABLE_SESSIONS = 'sessions';
+
+const SESSIONS_TARGET_MODE_DEFAULT = "'yolo'";
+const SESSIONS_TARGET_THINKING_ENABLED_DEFAULT = '1';
+
+/**
+ * SQL column definitions for the sessions table with current defaults.
+ */
+export const SESSIONS_ALL_CURRENT_COLUMNS = `
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'starting' CHECK (status IN ('starting', 'running', 'waiting', 'stopped', 'completed', 'error', 'scheduled')),
+    mode TEXT NOT NULL DEFAULT 'yolo' CHECK (mode IN ('plan', 'standard', 'yolo')),
+    thinking_enabled INTEGER NOT NULL DEFAULT 1,
+    archived INTEGER NOT NULL DEFAULT 0,
+    git_branch TEXT,
+    git_worktree TEXT,
+    pr_url TEXT,
+    error TEXT,
+    effort_level TEXT CHECK(effort_level IN ('low', 'medium', 'high', 'max', 'auto')),
+    cost_usd REAL DEFAULT 0,
+    claude_session_id TEXT,
+    model TEXT,
+    provider_id TEXT,
+    next_template_id TEXT REFERENCES session_templates(id) ON DELETE SET NULL,
+    parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+    input_tokens INTEGER DEFAULT 0,
+    output_tokens INTEGER DEFAULT 0,
+    thinking_tokens INTEGER DEFAULT 0,
+    cache_read_input_tokens INTEGER DEFAULT 0,
+    cache_creation_input_tokens INTEGER DEFAULT 0,
+    web_search_requests INTEGER DEFAULT 0,
+    context_window INTEGER DEFAULT 200000,
+    starred INTEGER NOT NULL DEFAULT 0,
+    manually_named INTEGER NOT NULL DEFAULT 0,
+    scheduled_at INTEGER DEFAULT NULL,
+    reschedule_delay_minutes INTEGER DEFAULT 15,
+    auto_reschedule_enabled INTEGER DEFAULT 0,
+    reschedule_on_token_limit INTEGER DEFAULT 1,
+    reschedule_on_service_error INTEGER DEFAULT 1,
+    max_reschedule_count INTEGER DEFAULT NULL,
+    max_total_tokens INTEGER DEFAULT NULL,
+    reschedule_count INTEGER DEFAULT 0,
+    reschedule_at_token_count INTEGER DEFAULT NULL,
+    pending_prompt TEXT,
+    slash_commands TEXT,
+    pending_model TEXT,
+    auto_send_pending_prompt INTEGER DEFAULT 0,
+    agent_type TEXT DEFAULT 'claude-code',
+    target_lane_id TEXT REFERENCES kanban_lanes(id) ON DELETE SET NULL,
+    lane_trigger_depth INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+`;
+
+export const SESSIONS_ALL_CURRENT_COLUMN_NAMES = [
+  'id', 'project_id', 'name', 'status', 'mode', 'thinking_enabled',
+  'archived', 'git_branch', 'git_worktree', 'pr_url', 'error',
+  'effort_level', 'cost_usd', 'claude_session_id', 'model', 'provider_id',
+  'next_template_id', 'parent_session_id', 'input_tokens', 'output_tokens',
+  'thinking_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens',
+  'web_search_requests', 'context_window', 'starred', 'manually_named',
+  'scheduled_at', 'reschedule_delay_minutes', 'auto_reschedule_enabled',
+  'reschedule_on_token_limit', 'reschedule_on_service_error',
+  'max_reschedule_count', 'max_total_tokens', 'reschedule_count',
+  'reschedule_at_token_count', 'pending_prompt', 'slash_commands',
+  'pending_model', 'auto_send_pending_prompt', 'agent_type', 'target_lane_id',
+  'lane_trigger_depth', 'created_at', 'updated_at',
+];
+
+/**
+ * Recreate the sessions table with the given column SQL, preserving existing data.
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} columnsSql
+ * @param {string[]} allColumnNames
+ */
+export function recreateSessionsTable(db, columnsSql, allColumnNames) {
+  const existingColumnNames = getColumns(db, TABLE_SESSIONS);
+  const selectColumns = allColumnNames
+    .filter((col) => existingColumnNames.includes(col))
+    .join(', ');
+
+  const foreignKeysEnabled = db.pragma('foreign_keys', { simple: true });
+  db.pragma('foreign_keys = OFF');
+
+  try {
+    db.exec(`
+      CREATE TABLE sessions_new (${columnsSql});
+      INSERT INTO sessions_new (${selectColumns})
+      SELECT ${selectColumns} FROM sessions;
+      DROP TABLE sessions;
+      ALTER TABLE sessions_new RENAME TO sessions;
+      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status);
+      CREATE INDEX IF NOT EXISTS idx_sessions_archived ON sessions(archived);
+      CREATE INDEX IF NOT EXISTS idx_sessions_starred ON sessions(archived, starred);
+      CREATE INDEX IF NOT EXISTS idx_sessions_next_template ON sessions(next_template_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_parent ON sessions(parent_session_id);
+      CREATE INDEX IF NOT EXISTS idx_sessions_scheduled ON sessions(scheduled_at) WHERE scheduled_at IS NOT NULL;
+    `);
+
+    const foreignKeyViolations = db.pragma('foreign_key_check');
+    if (foreignKeyViolations.length > 0) {
+      throw new Error('sessions table migration failed foreign key check');
+    }
+  } finally {
+    db.pragma(`foreign_keys = ${foreignKeysEnabled ? 'ON' : 'OFF'}`);
+  }
+}
+
+/**
+ * Migrate sessions table defaults: mode → 'yolo', thinking_enabled → 1.
+ * No-op if the table already has the target defaults.
+ * @param {import('better-sqlite3').Database} db
+ */
+export function migrateSessionsDefaultModeAndThinking(db) {
+  const columns = db.prepare(`PRAGMA table_info(${TABLE_SESSIONS})`).all();
+  const modeColumn = columns.find((col) => col.name === 'mode');
+  const thinkingEnabledColumn = columns.find((col) => col.name === 'thinking_enabled');
+
+  if (
+    modeColumn?.dflt_value === SESSIONS_TARGET_MODE_DEFAULT
+    && thinkingEnabledColumn?.dflt_value === SESSIONS_TARGET_THINKING_ENABLED_DEFAULT
+  ) {
+    return;
+  }
+
+  recreateSessionsTable(db, SESSIONS_ALL_CURRENT_COLUMNS, SESSIONS_ALL_CURRENT_COLUMN_NAMES);
+}