@adriandmitroca/relay 0.0.2

package/src/db.ts

@@ -0,0 +1,718 @@
+import { Database } from "bun:sqlite";
+import { logger } from "./utils/logger.ts";
+import type { Config, WorkspaceConfig, ProjectConfig, SentrySourceConfig, AsanaSourceConfig, LinearSourceConfig, JiraSourceConfig } from "./config.ts";
+
+export type IssueStatus =
+  | "new"
+  | "triaging"
+  | "triaged_actionable"
+  | "triaged_not_actionable"
+  | "pending_confirmation"
+  | "working"
+  | "pending_approval"
+  | "accepted"
+  | "discarded"
+  | "skipped"
+  | "failed";
+
+export interface IssueRow {
+  id: number;
+  source: string;
+  sourceId: string;
+  projectKey: string;
+  workspaceKey: string;
+  externalUrl: string;
+  title: string;
+  body: string;
+  severity: string;
+  status: IssueStatus;
+  triageVerdict: string | null;
+  triageReason: string | null;
+  triagePlan: string | null;
+  triageConfidence: number | null;
+  fixSummary: string | null;
+  diffSummary: string | null;
+  diffPatch: string | null;
+  worktreePath: string | null;
+  branch: string | null;
+  prUrl: string | null;
+  telegramMessageId: number | null;
+  telegramThreadId: number | null;
+  sessionId: string | null;
+  failureReason: string | null;
+  triageDurationMs: number | null;
+  triageInputTokens: number | null;
+  triageOutputTokens: number | null;
+  triageCostUsd: number | null;
+  fixDurationMs: number | null;
+  fixInputTokens: number | null;
+  fixOutputTokens: number | null;
+  fixCostUsd: number | null;
+  metadata: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS issues (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  project_key TEXT NOT NULL,
+  workspace_key TEXT NOT NULL DEFAULT '',
+  external_url TEXT NOT NULL,
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  severity TEXT NOT NULL DEFAULT 'medium',
+  status TEXT NOT NULL DEFAULT 'new',
+  triage_verdict TEXT,
+  triage_reason TEXT,
+  triage_plan TEXT,
+  triage_confidence REAL,
+  fix_summary TEXT,
+  diff_summary TEXT,
+  diff_patch TEXT,
+  worktree_path TEXT,
+  branch TEXT,
+  pr_url TEXT,
+  telegram_message_id INTEGER,
+  telegram_thread_id INTEGER,
+  session_id TEXT,
+  failure_reason TEXT,
+  triage_duration_ms INTEGER,
+  triage_input_tokens INTEGER,
+  triage_output_tokens INTEGER,
+  triage_cost_usd REAL,
+  fix_duration_ms INTEGER,
+  fix_input_tokens INTEGER,
+  fix_output_tokens INTEGER,
+  fix_cost_usd REAL,
+  metadata TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(source, source_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_issues_status ON issues(status);
+CREATE INDEX IF NOT EXISTS idx_issues_source ON issues(source, source_id);
+CREATE INDEX IF NOT EXISTS idx_issues_project ON issues(project_key);
+CREATE INDEX IF NOT EXISTS idx_issues_workspace ON issues(workspace_key);
+`;
+
+function toRow(raw: Record<string, unknown>): IssueRow {
+  return {
+    id: raw.id as number,
+    source: raw.source as string,
+    sourceId: raw.source_id as string,
+    projectKey: raw.project_key as string,
+    workspaceKey: raw.workspace_key as string,
+    externalUrl: raw.external_url as string,
+    title: raw.title as string,
+    body: raw.body as string,
+    severity: raw.severity as string,
+    status: raw.status as IssueStatus,
+    triageVerdict: raw.triage_verdict as string | null,
+    triageReason: raw.triage_reason as string | null,
+    triagePlan: raw.triage_plan as string | null,
+    triageConfidence: raw.triage_confidence as number | null,
+    fixSummary: raw.fix_summary as string | null,
+    diffSummary: raw.diff_summary as string | null,
+    diffPatch: raw.diff_patch as string | null,
+    worktreePath: raw.worktree_path as string | null,
+    branch: raw.branch as string | null,
+    prUrl: raw.pr_url as string | null,
+    telegramMessageId: raw.telegram_message_id as number | null,
+    telegramThreadId: raw.telegram_thread_id as number | null,
+    sessionId: raw.session_id as string | null,
+    failureReason: raw.failure_reason as string | null,
+    triageDurationMs: raw.triage_duration_ms as number | null,
+    triageInputTokens: raw.triage_input_tokens as number | null,
+    triageOutputTokens: raw.triage_output_tokens as number | null,
+    triageCostUsd: raw.triage_cost_usd as number | null,
+    fixDurationMs: raw.fix_duration_ms as number | null,
+    fixInputTokens: raw.fix_input_tokens as number | null,
+    fixOutputTokens: raw.fix_output_tokens as number | null,
+    fixCostUsd: raw.fix_cost_usd as number | null,
+    metadata: raw.metadata as string | null,
+    createdAt: raw.created_at as string,
+    updatedAt: raw.updated_at as string,
+  };
+}
+
+export class IssueDB {
+  private db: Database;
+  private stmts: {
+    upsert: ReturnType<Database["prepare"]>;
+    get: ReturnType<Database["prepare"]>;
+    exists: ReturnType<Database["prepare"]>;
+    updateStatus: ReturnType<Database["prepare"]>;
+    getByStatus: ReturnType<Database["prepare"]>;
+    getRecent: ReturnType<Database["prepare"]>;
+  };
+
+  constructor(dbPath: string) {
+    this.db = new Database(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.db.exec("PRAGMA busy_timeout = 5000;");
+    this.db.exec(SCHEMA);
+
+    this.stmts = {
+      upsert: this.db.prepare(`
+        INSERT INTO issues (source, source_id, project_key, workspace_key, external_url, title, body, severity, metadata)
+        VALUES ($source, $sourceId, $projectKey, $workspaceKey, $externalUrl, $title, $body, $severity, $metadata)
+        ON CONFLICT(source, source_id) DO UPDATE SET
+          title = excluded.title,
+          body = excluded.body,
+          updated_at = datetime('now')
+        RETURNING *
+      `),
+      get: this.db.prepare("SELECT * FROM issues WHERE source = $source AND source_id = $sourceId"),
+      exists: this.db.prepare("SELECT 1 FROM issues WHERE source = $source AND source_id = $sourceId"),
+      updateStatus: this.db.prepare(`
+        UPDATE issues SET status = $status, updated_at = datetime('now') WHERE id = $id
+      `),
+      getByStatus: this.db.prepare("SELECT * FROM issues WHERE status = $status ORDER BY created_at DESC"),
+      getRecent: this.db.prepare("SELECT * FROM issues ORDER BY updated_at DESC LIMIT $limit"),
+    };
+
+    logger.debug("Database initialized", { path: dbPath });
+  }
+
+  upsert(issue: {
+    source: string;
+    sourceId: string;
+    projectKey: string;
+    workspaceKey: string;
+    externalUrl: string;
+    title: string;
+    body: string;
+    severity: string;
+    metadata?: Record<string, unknown>;
+  }): IssueRow {
+    const raw = this.stmts.upsert.get({
+      $source: issue.source,
+      $sourceId: issue.sourceId,
+      $projectKey: issue.projectKey,
+      $workspaceKey: issue.workspaceKey,
+      $externalUrl: issue.externalUrl,
+      $title: issue.title,
+      $body: issue.body,
+      $severity: issue.severity,
+      $metadata: issue.metadata ? JSON.stringify(issue.metadata) : null,
+    }) as Record<string, unknown>;
+    return toRow(raw);
+  }
+
+  get(source: string, sourceId: string): IssueRow | null {
+    const raw = this.stmts.get.get({ $source: source, $sourceId: sourceId }) as Record<string, unknown> | null;
+    return raw ? toRow(raw) : null;
+  }
+
+  exists(source: string, sourceId: string): boolean {
+    return this.stmts.exists.get({ $source: source, $sourceId: sourceId }) !== null;
+  }
+
+  updateStatus(id: number, status: IssueStatus) {
+    this.stmts.updateStatus.run({ $id: id, $status: status });
+  }
+
+  update(id: number, fields: Partial<Record<string, unknown>>) {
+    const sets: string[] = ["updated_at = datetime('now')"];
+    const params: Record<string, unknown> = { $id: id };
+
+    const fieldMap: Record<string, string> = {
+      status: "status",
+      triageVerdict: "triage_verdict",
+      triageReason: "triage_reason",
+      triagePlan: "triage_plan",
+      triageConfidence: "triage_confidence",
+      fixSummary: "fix_summary",
+      diffSummary: "diff_summary",
+      diffPatch: "diff_patch",
+      worktreePath: "worktree_path",
+      branch: "branch",
+      prUrl: "pr_url",
+      telegramMessageId: "telegram_message_id",
+      telegramThreadId: "telegram_thread_id",
+      sessionId: "session_id",
+      failureReason: "failure_reason",
+      triageDurationMs: "triage_duration_ms",
+      triageInputTokens: "triage_input_tokens",
+      triageOutputTokens: "triage_output_tokens",
+      triageCostUsd: "triage_cost_usd",
+      fixDurationMs: "fix_duration_ms",
+      fixInputTokens: "fix_input_tokens",
+      fixOutputTokens: "fix_output_tokens",
+      fixCostUsd: "fix_cost_usd",
+    };
+
+    for (const [key, value] of Object.entries(fields)) {
+      const col = fieldMap[key];
+      if (!col) continue;
+      sets.push(`${col} = $${key}`);
+      params[`$${key}`] = value;
+    }
+
+    this.db.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE id = $id`).run(params);
+  }
+
+  getByStatus(status: IssueStatus): IssueRow[] {
+    const rows = this.stmts.getByStatus.all({ $status: status }) as Record<string, unknown>[];
+    return rows.map(toRow);
+  }
+
+  getRecent(limit = 20): IssueRow[] {
+    const rows = this.stmts.getRecent.all({ $limit: limit }) as Record<string, unknown>[];
+    return rows.map(toRow);
+  }
+
+  getStats(): Record<string, number> {
+    const rows = this.db
+      .prepare("SELECT status, COUNT(*) as count FROM issues GROUP BY status")
+      .all() as { status: string; count: number }[];
+    const stats: Record<string, number> = {};
+    for (const r of rows) stats[r.status] = r.count;
+    return stats;
+  }
+
+  getStatsBySource(workspaceKey?: string): Array<{ source: string; status: string; count: number }> {
+    const where = workspaceKey ? "WHERE workspace_key = $workspaceKey" : "";
+    const params = workspaceKey ? { $workspaceKey: workspaceKey } : {};
+    return this.db
+      .prepare(`SELECT source, status, COUNT(*) as count FROM issues ${where} GROUP BY source, status`)
+      .all(params) as Array<{ source: string; status: string; count: number }>;
+  }
+
+  getById(id: number): IssueRow | null {
+    const raw = this.db.prepare("SELECT * FROM issues WHERE id = $id").get({ $id: id }) as Record<string, unknown> | null;
+    return raw ? toRow(raw) : null;
+  }
+
+  getFiltered(opts: { status?: string; source?: string; workspaceKey?: string; limit?: number }): IssueRow[] {
+    const conditions: string[] = [];
+    const params: Record<string, unknown> = {};
+
+    if (opts.status) {
+      conditions.push("status = $status");
+      params.$status = opts.status;
+    }
+    if (opts.source) {
+      conditions.push("source = $source");
+      params.$source = opts.source;
+    }
+    if (opts.workspaceKey) {
+      conditions.push("workspace_key = $workspaceKey");
+      params.$workspaceKey = opts.workspaceKey;
+    }
+
+    const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = opts.limit ?? 50;
+    const rows = this.db
+      .prepare(`SELECT * FROM issues ${where} ORDER BY updated_at DESC LIMIT ${limit}`)
+      .all(params) as Record<string, unknown>[];
+    return rows.map(toRow);
+  }
+
+  resetStuckIssues(): IssueRow[] {
+    const stuck = this.db.prepare(`
+      SELECT * FROM issues WHERE status IN ('triaging', 'working')
+    `).all() as Record<string, unknown>[];
+
+    if (stuck.length > 0) {
+      // Issues that were working go back to pending_confirmation (require user re-confirmation)
+      this.db.prepare(`
+        UPDATE issues SET status = 'pending_confirmation', updated_at = datetime('now')
+        WHERE status = 'working'
+      `).run();
+      // Issues that were triaging go back to new
+      this.db.prepare(`
+        UPDATE issues SET status = 'new', updated_at = datetime('now')
+        WHERE status = 'triaging'
+      `).run();
+      logger.warn("Re-queued interrupted issues", { count: stuck.length });
+    }
+
+    return stuck.map(toRow);
+  }
+
+  close() {
+    this.db.close();
+  }
+
+  getDatabase(): Database {
+    return this.db;
+  }
+}
+
+// ─── Config DB ───
+
+const CONFIG_SCHEMA = `
+CREATE TABLE IF NOT EXISTS settings (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS workspaces (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  key TEXT UNIQUE NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS projects (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  workspace_id INTEGER NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+  key TEXT UNIQUE NOT NULL,
+  repo_path TEXT NOT NULL,
+  base_branch TEXT NOT NULL DEFAULT 'main',
+  test_command TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS source_configs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  type TEXT NOT NULL,
+  config TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+  UNIQUE(project_id, type)
+);
+
+CREATE TABLE IF NOT EXISTS telegram_configs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  workspace_id INTEGER NOT NULL UNIQUE REFERENCES workspaces(id) ON DELETE CASCADE,
+  bot_token TEXT NOT NULL,
+  chat_id TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+
+const DEFAULT_SETTINGS: Record<string, string> = {
+  pollIntervalSeconds: "300",
+  maxConcurrency: "2",
+  claudeTimeout: "300000",
+  triageTimeout: "120000",
+  triage: "true",
+  logLevel: "info",
+  allowedTools: '["Read","Write","Edit","Bash","Glob","Grep"]',
+};
+
+export interface WorkspaceRow {
+  id: number;
+  key: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface ProjectRow {
+  id: number;
+  workspace_id: number;
+  key: string;
+  repo_path: string;
+  base_branch: string;
+  test_command: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface SourceConfigRow {
+  id: number;
+  project_id: number;
+  type: string;
+  config: string;
+  enabled: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface TelegramConfigRow {
+  id: number;
+  workspace_id: number;
+  bot_token: string;
+  chat_id: string;
+  enabled: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export class ConfigDB {
+  private db: Database;
+
+  constructor(db: Database) {
+    this.db = db;
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.db.exec(CONFIG_SCHEMA);
+    this.seedDefaults();
+  }
+
+  private seedDefaults() {
+    const existing = this.db.prepare("SELECT COUNT(*) as count FROM settings").get() as { count: number };
+    if (existing.count === 0) {
+      const stmt = this.db.prepare("INSERT OR IGNORE INTO settings (key, value) VALUES ($key, $value)");
+      for (const [key, value] of Object.entries(DEFAULT_SETTINGS)) {
+        stmt.run({ $key: key, $value: value });
+      }
+    }
+  }
+
+  // ─── Settings ───
+
+  getSettings(): Record<string, string> {
+    const rows = this.db.prepare("SELECT key, value FROM settings").all() as { key: string; value: string }[];
+    const result: Record<string, string> = {};
+    for (const r of rows) result[r.key] = r.value;
+    return result;
+  }
+
+  getSetting(key: string): string | null {
+    const row = this.db.prepare("SELECT value FROM settings WHERE key = $key").get({ $key: key }) as { value: string } | null;
+    return row?.value ?? null;
+  }
+
+  updateSettings(settings: Record<string, string>) {
+    const stmt = this.db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES ($key, $value)");
+    for (const [key, value] of Object.entries(settings)) {
+      stmt.run({ $key: key, $value: value });
+    }
+  }
+
+  // ─── Workspaces ───
+
+  getWorkspaces(): WorkspaceRow[] {
+    return this.db.prepare("SELECT * FROM workspaces ORDER BY id").all() as WorkspaceRow[];
+  }
+
+  getWorkspace(id: number): WorkspaceRow | null {
+    return this.db.prepare("SELECT * FROM workspaces WHERE id = $id").get({ $id: id }) as WorkspaceRow | null;
+  }
+
+  createWorkspace(key: string): WorkspaceRow {
+    return this.db.prepare("INSERT INTO workspaces (key) VALUES ($key) RETURNING *").get({ $key: key }) as WorkspaceRow;
+  }
+
+  updateWorkspace(id: number, key: string): void {
+    this.db.prepare("UPDATE workspaces SET key = $key, updated_at = datetime('now') WHERE id = $id").run({ $id: id, $key: key });
+  }
+
+  deleteWorkspace(id: number): void {
+    this.db.prepare("DELETE FROM workspaces WHERE id = $id").run({ $id: id });
+  }
+
+  // ─── Projects ───
+
+  getProjects(workspaceId: number): ProjectRow[] {
+    return this.db.prepare("SELECT * FROM projects WHERE workspace_id = $wsId ORDER BY id").all({ $wsId: workspaceId }) as ProjectRow[];
+  }
+
+  getProject(id: number): ProjectRow | null {
+    return this.db.prepare("SELECT * FROM projects WHERE id = $id").get({ $id: id }) as ProjectRow | null;
+  }
+
+  createProject(workspaceId: number, data: { key: string; repoPath: string; baseBranch: string; testCommand?: string }): ProjectRow {
+    return this.db.prepare(
+      "INSERT INTO projects (workspace_id, key, repo_path, base_branch, test_command) VALUES ($wsId, $key, $repoPath, $baseBranch, $testCommand) RETURNING *",
+    ).get({
+      $wsId: workspaceId,
+      $key: data.key,
+      $repoPath: data.repoPath,
+      $baseBranch: data.baseBranch,
+      $testCommand: data.testCommand ?? null,
+    }) as ProjectRow;
+  }
+
+  updateProject(id: number, data: { key?: string; repoPath?: string; baseBranch?: string; testCommand?: string | null }): void {
+    const sets: string[] = ["updated_at = datetime('now')"];
+    const params: Record<string, unknown> = { $id: id };
+    if (data.key !== undefined) { sets.push("key = $key"); params.$key = data.key; }
+    if (data.repoPath !== undefined) { sets.push("repo_path = $repoPath"); params.$repoPath = data.repoPath; }
+    if (data.baseBranch !== undefined) { sets.push("base_branch = $baseBranch"); params.$baseBranch = data.baseBranch; }
+    if (data.testCommand !== undefined) { sets.push("test_command = $testCommand"); params.$testCommand = data.testCommand; }
+    this.db.prepare(`UPDATE projects SET ${sets.join(", ")} WHERE id = $id`).run(params);
+  }
+
+  deleteProject(id: number): void {
+    this.db.prepare("DELETE FROM projects WHERE id = $id").run({ $id: id });
+  }
+
+  // ─── Source Configs ───
+
+  getSourceConfigs(projectId: number): SourceConfigRow[] {
+    return this.db.prepare("SELECT * FROM source_configs WHERE project_id = $pId ORDER BY id").all({ $pId: projectId }) as SourceConfigRow[];
+  }
+
+  getSourceConfig(id: number): SourceConfigRow | null {
+    return this.db.prepare("SELECT * FROM source_configs WHERE id = $id").get({ $id: id }) as SourceConfigRow | null;
+  }
+
+  upsertSourceConfig(projectId: number, type: string, config: Record<string, unknown>, enabled = true): SourceConfigRow {
+    return this.db.prepare(
+      `INSERT INTO source_configs (project_id, type, config, enabled)
+       VALUES ($pId, $type, $config, $enabled)
+       ON CONFLICT(project_id, type) DO UPDATE SET
+         config = excluded.config, enabled = excluded.enabled, updated_at = datetime('now')
+       RETURNING *`,
+    ).get({
+      $pId: projectId,
+      $type: type,
+      $config: JSON.stringify(config),
+      $enabled: enabled ? 1 : 0,
+    }) as SourceConfigRow;
+  }
+
+  updateSourceConfig(id: number, data: { config?: Record<string, unknown>; enabled?: boolean }): void {
+    const sets: string[] = ["updated_at = datetime('now')"];
+    const params: Record<string, unknown> = { $id: id };
+    if (data.config !== undefined) { sets.push("config = $config"); params.$config = JSON.stringify(data.config); }
+    if (data.enabled !== undefined) { sets.push("enabled = $enabled"); params.$enabled = data.enabled ? 1 : 0; }
+    this.db.prepare(`UPDATE source_configs SET ${sets.join(", ")} WHERE id = $id`).run(params);
+  }
+
+  deleteSourceConfig(id: number): void {
+    this.db.prepare("DELETE FROM source_configs WHERE id = $id").run({ $id: id });
+  }
+
+  // ─── Telegram Configs ───
+
+  getTelegramConfig(workspaceId: number): TelegramConfigRow | null {
+    return this.db.prepare("SELECT * FROM telegram_configs WHERE workspace_id = $wsId").get({ $wsId: workspaceId }) as TelegramConfigRow | null;
+  }
+
+  upsertTelegramConfig(workspaceId: number, botToken: string, chatId: string, enabled = true): TelegramConfigRow {
+    return this.db.prepare(
+      `INSERT INTO telegram_configs (workspace_id, bot_token, chat_id, enabled)
+       VALUES ($wsId, $botToken, $chatId, $enabled)
+       ON CONFLICT(workspace_id) DO UPDATE SET
+         bot_token = excluded.bot_token, chat_id = excluded.chat_id, enabled = excluded.enabled, updated_at = datetime('now')
+       RETURNING *`,
+    ).get({
+      $wsId: workspaceId,
+      $botToken: botToken,
+      $chatId: chatId,
+      $enabled: enabled ? 1 : 0,
+    }) as TelegramConfigRow;
+  }
+
+  updateTelegramEnabled(workspaceId: number, enabled: boolean): void {
+    this.db.prepare("UPDATE telegram_configs SET enabled = $enabled, updated_at = datetime('now') WHERE workspace_id = $wsId").run({
+      $wsId: workspaceId,
+      $enabled: enabled ? 1 : 0,
+    });
+  }
+
+  deleteTelegramConfig(workspaceId: number): void {
+    this.db.prepare("DELETE FROM telegram_configs WHERE workspace_id = $wsId").run({ $wsId: workspaceId });
+  }
+
+  // ─── Config Check & Import ───
+
+  hasConfig(): boolean {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM workspaces").get() as { count: number };
+    return row.count > 0;
+  }
+
+  importFromJson(config: Config): void {
+    this.db.exec("BEGIN TRANSACTION");
+    try {
+      // Import settings
+      const settingsMap: Record<string, string> = {
+        pollIntervalSeconds: String(config.pollIntervalSeconds),
+        maxConcurrency: String(config.maxConcurrency),
+        claudeTimeout: String(config.claudeTimeout),
+        triageTimeout: String(config.triageTimeout),
+        triage: String(config.triage),
+        logLevel: config.logLevel,
+        allowedTools: JSON.stringify(config.allowedTools),
+      };
+      this.updateSettings(settingsMap);
+
+      // Import workspaces
+      for (const ws of config.workspaces) {
+        const wsRow = this.createWorkspace(ws.key);
+
+        if (ws.telegram) {
+          this.upsertTelegramConfig(wsRow.id, ws.telegram.botToken, ws.telegram.chatId);
+        }
+
+        for (const proj of ws.projects) {
+          const projRow = this.createProject(wsRow.id, {
+            key: proj.key,
+            repoPath: proj.repoPath,
+            baseBranch: proj.baseBranch,
+            testCommand: proj.testCommand,
+          });
+
+          if (proj.sources.sentry) {
+            this.upsertSourceConfig(projRow.id, "sentry", proj.sources.sentry as unknown as Record<string, unknown>);
+          }
+          if (proj.sources.asana) {
+            this.upsertSourceConfig(projRow.id, "asana", proj.sources.asana as unknown as Record<string, unknown>);
+          }
+          if (proj.sources.linear) {
+            this.upsertSourceConfig(projRow.id, "linear", proj.sources.linear as unknown as Record<string, unknown>);
+          }
+          if (proj.sources.jira) {
+            this.upsertSourceConfig(projRow.id, "jira", proj.sources.jira as unknown as Record<string, unknown>);
+          }
+        }
+      }
+
+      this.db.exec("COMMIT");
+      logger.info("Imported config from JSON to DB", { workspaces: config.workspaces.length });
+    } catch (err) {
+      this.db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+
+  toConfig(): Config {
+    const settings = this.getSettings();
+    const workspaces: WorkspaceConfig[] = [];
+
+    for (const ws of this.getWorkspaces()) {
+      const telegram = this.getTelegramConfig(ws.id);
+      const projects: ProjectConfig[] = [];
+
+      for (const proj of this.getProjects(ws.id)) {
+        const sources: ProjectConfig["sources"] = {};
+        for (const src of this.getSourceConfigs(proj.id)) {
+          if (!src.enabled) continue;
+          const parsed = JSON.parse(src.config);
+          if (src.type === "sentry") sources.sentry = parsed as SentrySourceConfig;
+          if (src.type === "asana") sources.asana = parsed as AsanaSourceConfig;
+          if (src.type === "linear") sources.linear = parsed as LinearSourceConfig;
+          if (src.type === "jira") sources.jira = parsed as JiraSourceConfig;
+        }
+
+        projects.push({
+          key: proj.key,
+          repoPath: proj.repo_path,
+          baseBranch: proj.base_branch,
+          testCommand: proj.test_command ?? undefined,
+          sources,
+        });
+      }
+
+      const wsConfig: WorkspaceConfig = { key: ws.key, projects };
+      if (telegram?.enabled) {
+        wsConfig.telegram = { botToken: telegram.bot_token, chatId: telegram.chat_id };
+      }
+      workspaces.push(wsConfig);
+    }
+
+    return {
+      workspaces,
+      pollIntervalSeconds: parseInt(settings.pollIntervalSeconds ?? "300"),
+      maxConcurrency: parseInt(settings.maxConcurrency ?? "2"),
+      claudeTimeout: parseInt(settings.claudeTimeout ?? "300000"),
+      triageTimeout: parseInt(settings.triageTimeout ?? "120000"),
+      triage: settings.triage !== "false",
+      logLevel: (settings.logLevel ?? "info") as Config["logLevel"],
+      allowedTools: JSON.parse(settings.allowedTools ?? '["Read","Write","Edit","Bash","Glob","Grep"]'),
+    };
+  }
+}