jettypod 4.4.118 → 4.4.121

package/apps/dashboard/lib/data-bridge.ts

@@ -0,0 +1,722 @@
+/**
+ * Data Bridge — provides all data operations via Tauri IPC.
+ * Low-level invoke/listen/isTauri are in lib/tauri.ts.
+ */
+
+import { invoke } from './tauri';
+import type { TestDashboardData, PrototypeDashboardData } from './db';
+import type { EnvironmentConfig, ContextItem } from './environment-config';
+import { validateCategory, validateFaIcon } from './environment-config';
+
+// Work item types matching Tauri IPC response format
+// Note: Rust WorkItemResponse uses #[serde(rename = "type")] so JSON key is "type"
+export interface WorkItemData {
+  id: number;
+  type: string;
+  title: string;
+  description: string | null;
+  status: string;
+  mode: string | null;
+  phase: string | null;
+  parent_id: number | null;
+  branch_name: string | null;
+  scenario_file: string | null;
+  created_at: string;
+  completed_at: string | null;
+  ready_for_review: number;
+  display_order: number;
+  rejection_count: number;
+  rejection_reason: string | null;
+  rejection_round: number | null;
+  rejection_history: string | null;
+  needs_discovery: number;
+  qa_steps: string | null;
+}
+
+export interface DecisionData {
+  id: number;
+  work_item_id: number;
+  work_item_title: string;
+  aspect: string;
+  decision: string;
+  rationale: string | null;
+  created_at: string;
+}
+
+// Kanban types (matching what components expect)
+export interface InFlightItem {
+  id: number;
+  type: string;
+  title: string;
+  status: string;
+  mode: string | null;
+  phase: string | null;
+  parent_id: number | null;
+  parent_title: string | null;
+  parent_type: string | null;
+  branch_name: string | null;
+  ready_for_review: number;
+  display_order: number;
+  description: string | null;
+  rejection_count: number;
+  rejection_reason: string | null;
+  needs_discovery: number;
+  created_at: string;
+  completed_at: string | null;
+  rejection_round: number | null;
+  rejection_history: string | null;
+  // Aliases for backward compatibility with components
+  epicTitle: string | null;
+  epic_id: number | null;
+  // Children nested under feature cards (populated by transformToKanbanData)
+  chores?: InFlightItem[];
+  bugs?: InFlightItem[];
+  conversational?: number;
+  scenario_file?: string | null;
+}
+
+export interface KanbanGroup {
+  epicId: number | null;
+  epicTitle: string | null;
+  items: InFlightItem[];
+}
+
+export interface KanbanData {
+  inFlight: InFlightItem[];
+  backlog: Map<string, KanbanGroup>;
+  done: Map<string, KanbanGroup>;
+  /** O(1) item lookup by ID — built once during transform */
+  itemMap: Map<number, InFlightItem>;
+  /** O(1) status lookup by ID — built once during transform */
+  statusMap: Map<number, string>;
+}
+
+// Project config (matches Rust ProjectConfig serialization)
+export interface ProjectConfig {
+  name: string;
+  stage: string;
+  bundles: string[];
+  project_state: string;
+  project_discovery: {
+    status: string;
+    prototypes: unknown[];
+    winner: string | null;
+    rationale: string | null;
+    started_date: string | null;
+    completed_date: string | null;
+  };
+  mainBranch?: string | null;
+  [key: string]: unknown;
+}
+
+// ---- Helper: transform work items into kanban format ----
+
+function toInFlightItem(item: WorkItemData, parentMap: Map<number, WorkItemData>): InFlightItem {
+  const parent = item.parent_id ? parentMap.get(item.parent_id) : null;
+  return {
+    id: item.id,
+    type: item.type,
+    title: item.title,
+    status: item.status,
+    mode: item.mode,
+    phase: item.phase,
+    parent_id: item.parent_id,
+    parent_title: parent?.title ?? null,
+    parent_type: parent?.type ?? null,
+    branch_name: item.branch_name,
+    ready_for_review: item.ready_for_review,
+    display_order: item.display_order,
+    description: item.description,
+    rejection_count: item.rejection_count,
+    rejection_reason: item.rejection_reason,
+    needs_discovery: item.needs_discovery,
+    created_at: item.created_at,
+    completed_at: item.completed_at,
+    rejection_round: item.rejection_round ?? null,
+    rejection_history: item.rejection_history ?? null,
+    // Backward compatibility aliases
+    epicTitle: parent?.title ?? null,
+    epic_id: item.parent_id,
+  };
+}
+
+function groupByEpic(items: InFlightItem[], sort: 'display_order' | 'completed_at_desc' = 'display_order'): Map<string, KanbanGroup> {
+  const groups = new Map<string, KanbanGroup>();
+  for (const item of items) {
+    const key = item.parent_id ? String(item.parent_id) : 'ungrouped';
+    const existing = groups.get(key);
+    if (existing) {
+      existing.items.push(item);
+    } else {
+      groups.set(key, {
+        epicId: item.parent_id,
+        epicTitle: item.parent_title,
+        items: [item],
+      });
+    }
+  }
+  const compareFn = sort === 'completed_at_desc'
+    ? (a: InFlightItem, b: InFlightItem) => (b.completed_at ?? '').localeCompare(a.completed_at ?? '')
+    : (a: InFlightItem, b: InFlightItem) => (a.display_order ?? a.id * 10) - (b.display_order ?? b.id * 10);
+  for (const group of groups.values()) {
+    group.items.sort(compareFn);
+  }
+  return groups;
+}
+
+export function transformToKanbanData(allItems: WorkItemData[]): KanbanData {
+  // Build parent lookup map
+  const parentMap = new Map<number, WorkItemData>();
+  for (const item of allItems) {
+    parentMap.set(item.id, item);
+  }
+
+  // Identify feature IDs so we can nest their children instead of showing them as separate cards
+  const featureIds = new Set<number>();
+  for (const item of allItems) {
+    if (item.type === 'feature') featureIds.add(item.id);
+  }
+
+  // Collect children of features separately — they'll be nested, not shown as cards
+  const featureChildren: InFlightItem[] = [];
+
+  // Separate into categories
+  // In-flight: non-epic items with status 'in_progress' or 'blocked'
+  // Backlog: non-epic items with status 'backlog' or 'todo'
+  // Done: non-epic items with status 'done' or 'cancelled'
+  const inFlightItems: InFlightItem[] = [];
+  const backlogItems: InFlightItem[] = [];
+  const doneItems: InFlightItem[] = [];
+
+  for (const item of allItems) {
+    // Skip epics — they're containers, not kanban cards
+    if (item.type === 'epic') continue;
+
+    const inflightItem = toInFlightItem(item, parentMap);
+
+    // If this item's parent is a feature, collect it for nesting rather than
+    // showing as a separate card
+    if (item.parent_id && featureIds.has(item.parent_id)) {
+      featureChildren.push(inflightItem);
+      continue;
+    }
+
+    if (item.status === 'in_progress' || item.status === 'blocked') {
+      inFlightItems.push(inflightItem);
+    } else if (item.status === 'done' || item.status === 'cancelled') {
+      doneItems.push(inflightItem);
+    } else {
+      // backlog, todo
+      backlogItems.push(inflightItem);
+    }
+  }
+
+  // Sort in-flight by display_order (fall back to id * 10 for null — matches midpoint gap)
+  inFlightItems.sort((a, b) => (a.display_order ?? a.id * 10) - (b.display_order ?? b.id * 10));
+
+  const backlog = groupByEpic(backlogItems);
+  const done = groupByEpic(doneItems, 'completed_at_desc');
+
+  // Build lookup maps once during transform — consumers use these instead of
+  // scanning all items with O(N) loops on every access.
+  const itemMap = new Map<number, InFlightItem>();
+  const statusMap = new Map<number, string>();
+  for (const item of inFlightItems) {
+    itemMap.set(item.id, item);
+    statusMap.set(item.id, item.status);
+  }
+  for (const group of backlog.values()) {
+    for (const item of group.items) {
+      itemMap.set(item.id, item);
+      statusMap.set(item.id, item.status);
+    }
+  }
+  for (const group of done.values()) {
+    for (const item of group.items) {
+      itemMap.set(item.id, item);
+      statusMap.set(item.id, item.status);
+    }
+  }
+
+  // Nest feature children (chores/bugs) onto their parent feature items
+  // Also add children to itemMap/statusMap so they're findable
+  for (const child of featureChildren) {
+    const parent = itemMap.get(child.parent_id!);
+    if (parent) {
+      if (child.type === 'bug') {
+        if (!parent.bugs) parent.bugs = [];
+        parent.bugs.push(child);
+      } else {
+        if (!parent.chores) parent.chores = [];
+        parent.chores.push(child);
+      }
+    }
+    itemMap.set(child.id, child);
+    statusMap.set(child.id, child.status);
+  }
+
+  return {
+    inFlight: inFlightItems,
+    backlog,
+    done,
+    itemMap,
+    statusMap,
+  };
+}
+
+// ---- Project root cache (static value, never changes in a session) ----
+
+let projectRootCache: string | null | undefined = undefined; // undefined = not fetched yet
+
+// ---- Kanban cache ----
+
+let kanbanCache: KanbanData | null = null;
+let lastRawFingerprint: string | null = null;
+let lastKanbanResult: KanbanData | null = null;
+
+/** Timestamp of the last local mutation. WebSocket db_change events that arrive
+ *  within a short window after a local mutation are skipped because the caller
+ *  already refreshed the data. */
+let lastLocalMutationTs = 0;
+
+/** How long (ms) after a local mutation to suppress WebSocket-triggered refetches. */
+const LOCAL_MUTATION_SUPPRESS_MS = 1500;
+
+/** Returns true if a local mutation happened recently enough that an incoming
+ *  WebSocket db_change is almost certainly an echo of our own write. */
+export function isLocalMutationRecent(): boolean {
+  return Date.now() - lastLocalMutationTs < LOCAL_MUTATION_SUPPRESS_MS;
+}
+
+/** Mark that a local mutation is in flight — suppresses WS-triggered refetches
+ *  without clearing the cache. Call this BEFORE the IPC so the suppression
+ *  window covers the entire round-trip. invalidateKanbanCache() extends the
+ *  window after the IPC completes. */
+export function markLocalMutation(): void {
+  lastLocalMutationTs = Date.now();
+}
+
+/** Clear the kanban cache so the next getKanbanData() fetches fresh from DB. */
+export function invalidateKanbanCache(): void {
+  kanbanCache = null;
+  lastLocalMutationTs = Date.now();
+}
+
+/** Apply a field-level update to the cached kanban data without full invalidation.
+ *  Returns true if the item was found and updated, false otherwise. */
+function applyCacheUpdate(id: number, updates: Partial<Pick<InFlightItem, 'title' | 'description'>>): boolean {
+  if (!kanbanCache) return false;
+  const item = kanbanCache.itemMap.get(id);
+  if (!item) return false;
+
+  // Apply updates in place
+  if (updates.title !== undefined) {
+    item.title = updates.title;
+    // Update fingerprint to match new state
+    if (lastRawFingerprint) {
+      lastRawFingerprint = lastRawFingerprint.replace(
+        new RegExp(`${id}:${item.status}:${item.display_order}:[^;]*;`),
+        `${id}:${item.status}:${item.display_order}:${updates.title};`
+      );
+    }
+  }
+  if (updates.description !== undefined) {
+    item.description = updates.description;
+  }
+  lastLocalMutationTs = Date.now();
+  return true;
+}
+
+// ---- Delta update support ----
+
+/** Fetch a single work item by ID and patch it into the kanban cache.
+ *  Returns the updated KanbanData if the cache was patched, or null if a full
+ *  refetch is needed (item not in cache, status changed requiring column move,
+ *  or cache is cold). */
+export async function patchKanbanItem(rowid: number): Promise<KanbanData | null> {
+  if (!kanbanCache) return null;
+
+  const rawItem = await invoke<WorkItemData | null>('db_get_work_item', { id: rowid });
+  if (!rawItem) return null;
+
+  // Skip epics — they're containers, not kanban cards
+  if (rawItem.type === 'epic') return kanbanCache;
+
+  const existing = kanbanCache.itemMap.get(rowid);
+  if (!existing) {
+    // Item not in cache (new item or cache stale) — caller should full refetch
+    return null;
+  }
+
+  // If status changed, the item needs to move between columns — that's complex
+  // enough that a full refetch is cleaner and these are infrequent events
+  if (rawItem.status !== existing.status) {
+    return null;
+  }
+
+  // Build parent lookup from cache for the toInFlightItem-style transform
+  const parentTitle = existing.parent_title;
+  const parentType = existing.parent_type;
+
+  // Patch the item in place — same column, just updated fields
+  const patched: InFlightItem = {
+    ...existing,
+    title: rawItem.title,
+    description: rawItem.description,
+    mode: rawItem.mode,
+    phase: rawItem.phase,
+    branch_name: rawItem.branch_name,
+    ready_for_review: rawItem.ready_for_review,
+    display_order: rawItem.display_order,
+    rejection_count: rawItem.rejection_count,
+    rejection_reason: rawItem.rejection_reason,
+    needs_discovery: rawItem.needs_discovery,
+    scenario_file: rawItem.scenario_file,
+    completed_at: rawItem.completed_at,
+    parent_title: parentTitle,
+    parent_type: parentType,
+  };
+
+  // Update fingerprint to match new state
+  if (lastRawFingerprint) {
+    const oldPattern = `${rowid}:${existing.status}:${existing.display_order}:${existing.title};`;
+    const newPattern = `${rowid}:${patched.status}:${patched.display_order}:${patched.title};`;
+    lastRawFingerprint = lastRawFingerprint.replace(oldPattern, newPattern);
+  }
+
+  // Replace item in all data structures
+  const newItemMap = new Map(kanbanCache.itemMap);
+  newItemMap.set(rowid, patched);
+
+  const statusColumn = existing.status === 'in_progress' || existing.status === 'blocked'
+    ? 'inFlight' as const
+    : existing.status === 'done' || existing.status === 'cancelled'
+      ? 'done' as const
+      : 'backlog' as const;
+
+  let newInFlight = kanbanCache.inFlight;
+  let newBacklog = kanbanCache.backlog;
+  let newDone = kanbanCache.done;
+
+  if (statusColumn === 'inFlight') {
+    newInFlight = kanbanCache.inFlight.map(i => i.id === rowid ? patched : i);
+  } else {
+    const groups = statusColumn === 'backlog' ? kanbanCache.backlog : kanbanCache.done;
+    const newGroups = new Map<string, KanbanGroup>();
+    for (const [key, group] of groups) {
+      if (group.items.some(i => i.id === rowid)) {
+        newGroups.set(key, { ...group, items: group.items.map(i => i.id === rowid ? patched : i) });
+      } else {
+        newGroups.set(key, group);
+      }
+    }
+    if (statusColumn === 'backlog') newBacklog = newGroups;
+    else newDone = newGroups;
+  }
+
+  const result: KanbanData = {
+    inFlight: newInFlight,
+    backlog: newBacklog,
+    done: newDone,
+    itemMap: newItemMap,
+    statusMap: kanbanCache.statusMap,
+  };
+
+  kanbanCache = result;
+  lastKanbanResult = result;
+  return result;
+}
+
+// ---- Page data prefetch cache ----
+// Caches promises with a short TTL so hover-triggered fetches are reused by the
+// page component mount. After 10s the cache expires and the next access fetches fresh.
+
+const PREFETCH_TTL = 10_000;
+const pageCache = new Map<string, { promise: Promise<any>; ts: number }>();
+
+function getCachedOrFetch<T>(key: string, fetcher: () => Promise<T>): Promise<T> {
+  const cached = pageCache.get(key);
+  if (cached && Date.now() - cached.ts < PREFETCH_TTL) return cached.promise as Promise<T>;
+  const promise = fetcher();
+  pageCache.set(key, { promise, ts: Date.now() });
+  return promise;
+}
+
+export interface ContextDocument {
+  type: 'file' | 'text';
+  name: string;
+  content?: string;
+  path?: string;
+}
+
+export interface SettingsPrefetchData {
+  files: string[];
+  selected: string | null;
+  branch: string;
+  claudeModel: string | null;
+  designSystemDir: string | null;
+  contextDocuments: ContextDocument[];
+  environmentConfig: EnvironmentConfig | null;
+}
+
+export const prefetch = {
+  backlog(): Promise<KanbanData> {
+    return getCachedOrFetch('backlog', () => dataBridge.getKanbanData());
+  },
+  tests(): Promise<TestDashboardData> {
+    return getCachedOrFetch('tests', () => dataBridge.getTestDashboardData());
+  },
+  prototypes(): Promise<PrototypeDashboardData> {
+    return getCachedOrFetch('prototypes', () => dataBridge.getPrototypeDashboardData());
+  },
+  workItem(id: number): Promise<{ item: WorkItemData | null; children: WorkItemData[]; decisions: DecisionData[] }> {
+    return getCachedOrFetch(`workItem:${id}`, async () => {
+      const [item, children, decisions] = await Promise.all([
+        dataBridge.getWorkItem(id),
+        dataBridge.getChildren(id),
+        dataBridge.getDecisions(id),
+      ]);
+      return { item, children, decisions };
+    });
+  },
+  settings(): Promise<SettingsPrefetchData> {
+    return getCachedOrFetch('settings', async () => {
+      const [files, selected, branch, claudeModel, designSystemDir, contextDocuments, environmentConfig] = await Promise.all([
+        dataBridge.discoverEnvFiles(),
+        dataBridge.getSelectedEnvFile(),
+        dataBridge.getMainBranch(),
+        dataBridge.getClaudeModel(),
+        dataBridge.getDesignSystemDir(),
+        dataBridge.getContextDocuments(),
+        dataBridge.getEnvironmentConfig(),
+      ]);
+      return { files, selected, branch, claudeModel, designSystemDir, contextDocuments, environmentConfig };
+    });
+  },
+};
+
+// ---- Public API ----
+
+export const dataBridge = {
+  // Kanban / work items
+  async getKanbanData(): Promise<KanbanData> {
+    if (kanbanCache) return kanbanCache;
+    // Fetch all active items + the 25 most recent done/cancelled for the Done
+    // column.  This avoids loading 1,000+ completed items while still showing
+    // recent completions on the board.
+    const items = await invoke<WorkItemData[]>('db_get_tree', {
+      includeCompleted: true,
+      completedLimit: 25,
+    });
+    // Lightweight fingerprint — only hash id:status:order:title per item instead of
+    // full JSON.stringify. O(N) string concat is much cheaper than O(N) serialization.
+    let fingerprint = '';
+    for (const item of items) {
+      fingerprint += `${item.id}:${item.status}:${item.display_order}:${item.title};`;
+    }
+    if (fingerprint === lastRawFingerprint && lastKanbanResult) {
+      kanbanCache = lastKanbanResult;
+      return kanbanCache;
+    }
+    lastRawFingerprint = fingerprint;
+    kanbanCache = transformToKanbanData(items);
+    lastKanbanResult = kanbanCache;
+    return kanbanCache;
+  },
+
+  async getWorkItem(id: number): Promise<WorkItemData | null> {
+    try {
+      return await invoke<WorkItemData>('db_get_work_item', { id });
+    } catch {
+      return null;
+    }
+  },
+
+  async getChildren(parentId: number): Promise<WorkItemData[]> {
+    return invoke<WorkItemData[]>('db_get_children', { parentId });
+  },
+
+  async getDecisions(workItemId: number): Promise<DecisionData[]> {
+    return invoke<DecisionData[]>('db_get_decisions', { workItemId });
+  },
+
+  async getDecision(id: number): Promise<DecisionData | null> {
+    try {
+      return await invoke<DecisionData>('db_get_decision', { id });
+    } catch {
+      return null;
+    }
+  },
+
+  // Mutations (all invalidate kanban cache)
+  async updateStatus(id: number, status: string, rejectionReason?: string): Promise<boolean> {
+    const result = await invoke<boolean>('db_update_work_item_status', { id, status });
+    if (rejectionReason && status === 'in_progress') {
+      await invoke<boolean>('db_increment_rejection', { id, reason: rejectionReason });
+    }
+    invalidateKanbanCache();
+    return result;
+  },
+
+  async updateTitle(id: number, title: string): Promise<boolean> {
+    const result = await invoke<boolean>('db_update_work_item_title', { id, title });
+    // Optimistic: update cached item in place instead of full invalidation
+    if (!applyCacheUpdate(id, { title })) invalidateKanbanCache();
+    return result;
+  },
+
+  async updateDescription(id: number, description: string): Promise<boolean> {
+    const result = await invoke<boolean>('db_update_work_item_description', { id, description });
+    // Optimistic: update cached item in place instead of full invalidation
+    if (!applyCacheUpdate(id, { description })) invalidateKanbanCache();
+    return result;
+  },
+
+  async setQaSteps(id: number, qaSteps: string): Promise<boolean> {
+    return invoke<boolean>('db_set_work_item_qa_steps', { id, qaSteps });
+  },
+
+  async updateDisplayOrders(orders: [number, number][]): Promise<boolean> {
+    const result = await invoke<boolean>('db_update_display_orders', { orders });
+    invalidateKanbanCache();
+    return result;
+  },
+
+  // Project (cached — project root never changes in a session)
+  async hasProject(): Promise<boolean> {
+    const root = await this.getProjectRoot();
+    return root !== null;
+  },
+
+  async getProjectRoot(): Promise<string | null> {
+    if (projectRootCache !== undefined) return projectRootCache;
+    projectRootCache = await invoke<string | null>('db_get_project_root');
+    return projectRootCache;
+  },
+
+  // Settings
+  async getEnvVars(file: string): Promise<Array<{ key: string; value: string }>> {
+    return invoke<Array<{ key: string; value: string }>>('db_get_env_vars', { file });
+  },
+
+  async discoverEnvFiles(): Promise<string[]> {
+    return invoke<string[]>('db_discover_env_files');
+  },
+
+  async getSelectedEnvFile(): Promise<string | null> {
+    return invoke<string | null>('db_get_selected_env_file');
+  },
+
+  async getMainBranch(): Promise<string> {
+    return invoke<string>('db_get_main_branch');
+  },
+
+  async getClaudeModel(): Promise<string | null> {
+    return invoke<string | null>('db_get_claude_model');
+  },
+
+  async setClaudeModel(model: string): Promise<boolean> {
+    return invoke<boolean>('db_set_claude_model', { model });
+  },
+
+  async resetClaudeModel(): Promise<boolean> {
+    return invoke<boolean>('db_reset_claude_model');
+  },
+
+  async getDesignSystemDir(): Promise<string | null> {
+    return invoke<string | null>('db_get_design_system_dir');
+  },
+
+  async setDesignSystemDir(dir: string): Promise<boolean> {
+    return invoke<boolean>('db_set_design_system_dir', { dir });
+  },
+
+  async resetDesignSystemDir(): Promise<boolean> {
+    return invoke<boolean>('db_reset_design_system_dir');
+  },
+
+  // Context Documents
+  async getContextDocuments(): Promise<ContextDocument[]> {
+    return invoke<ContextDocument[]>('db_get_context_documents');
+  },
+
+  async addContextDocument(doc: ContextDocument): Promise<boolean> {
+    return invoke<boolean>('db_add_context_document', { doc });
+  },
+
+  async updateContextDocument(index: number, doc: ContextDocument): Promise<boolean> {
+    return invoke<boolean>('db_update_context_document', { index, doc });
+  },
+
+  async removeContextDocument(index: number): Promise<boolean> {
+    return invoke<boolean>('db_remove_context_document', { index });
+  },
+
+  // Environment Config
+  async getEnvironmentConfig(): Promise<EnvironmentConfig | null> {
+    try {
+      const fullConfig = await invoke<Record<string, unknown>>('db_get_config');
+      const env = fullConfig?.environment as Record<string, unknown> | undefined;
+      if (!env || typeof env !== 'object' || !Array.isArray(env.services) || env.services.length === 0) {
+        return null;
+      }
+      const contextItems = Array.isArray(env.contextItems)
+        ? (env.contextItems as ContextItem[]).map(item => ({
+            name: item.name,
+            category: item.category,
+            faIcon: item.faIcon,
+            command: item.command,
+            connectionUrl: item.connectionUrl,
+          }))
+        : [];
+
+      return {
+        services: (env.services as EnvironmentConfig['services']).map((svc, i) => ({
+          name: svc.name,
+          command: svc.command,
+          port: svc.port,
+          healthCheck: svc.healthCheck || 'http',
+          readyPattern: svc.readyPattern,
+          optional: svc.optional ?? false,
+          order: svc.order ?? i + 1,
+          category: validateCategory(svc.category),
+          faIcon: validateFaIcon(svc.faIcon),
+        })),
+        contextItems,
+        readyWhen: (env.readyWhen as EnvironmentConfig['readyWhen']) || 'required',
+        teardownOnClose: env.teardownOnClose !== false,
+      };
+    } catch {
+      return null;
+    }
+  },
+
+  async setEnvironmentConfig(config: EnvironmentConfig): Promise<boolean> {
+    try {
+      const result = await invoke<boolean>('db_set_environment_config', {
+        environment: config,
+      });
+      if (result) pageCache.delete('settings');
+      return result;
+    } catch {
+      return false;
+    }
+  },
+
+  // Tests & Prototypes
+  async getTestDashboardData(): Promise<TestDashboardData> {
+    return invoke<TestDashboardData>('db_get_test_dashboard_data');
+  },
+
+  async ingestTestResults(): Promise<number> {
+    return invoke<number>('ingest_test_results');
+  },
+
+  async getProjectRoot(): Promise<string | null> {
+    return invoke<string | null>('db_get_project_root');
+  },
+
+  async getPrototypeDashboardData(): Promise<PrototypeDashboardData> {
+    return invoke<PrototypeDashboardData>('db_get_prototype_dashboard_data');
+  },
+};