gloomberb 0.2.0 → 0.3.1

package/src/data/resource-store.ts

@@ -0,0 +1,323 @@
+import type { Database } from "bun:sqlite";
+import type { CachePolicy, PersistedResourceValue } from "../types/persistence";
+import type { JsonValue } from "./sqlite-json";
+import { safeParseJson, serializeJson } from "./sqlite-json";
+
+const RESOURCE_CACHE_SOFT_ROW_LIMIT = 25_000;
+const RESOURCE_CACHE_SOFT_SIZE_LIMIT = 100 * 1024 * 1024;
+const DEFAULT_RESOURCE_SCHEMA_VERSION = 1;
+const EMPTY_VARIANT_KEY = "";
+const EMPTY_SOURCE_KEY = "";
+
+interface ResourceCacheRow {
+  namespace: string;
+  kind: string;
+  entity_key: string;
+  variant_key: string;
+  source_key: string;
+  schema_version: number;
+  payload: string;
+  provenance: string | null;
+  fetched_at: number;
+  stale_at: number;
+  expires_at: number;
+  last_accessed_at: number;
+  size_bytes: number;
+}
+
+export interface ResourceCacheKey {
+  namespace: string;
+  kind: string;
+  entityKey: string;
+  variantKey?: string;
+  sourceKey?: string;
+}
+
+export interface CachedResourceRecord<T = unknown> extends PersistedResourceValue<T> {
+  namespace: string;
+  kind: string;
+  entityKey: string;
+  variantKey: string;
+  sourceKey: string;
+  provenance: JsonValue | null;
+  lastAccessedAt: number;
+  sizeBytes: number;
+}
+
+export interface SetResourceOptions {
+  schemaVersion?: number;
+  cachePolicy: CachePolicy;
+  provenance?: JsonValue | null;
+  fetchedAt?: number;
+}
+
+export interface GetResourceOptions {
+  schemaVersion?: number;
+  allowExpired?: boolean;
+  touch?: boolean;
+}
+
+export interface ListResourceOptions extends GetResourceOptions {
+  variantKeys?: string[];
+  sourceKeys?: string[];
+}
+
+function normalizeVariantKey(value: string | undefined): string {
+  return value ?? EMPTY_VARIANT_KEY;
+}
+
+function normalizeSourceKey(value: string | undefined): string {
+  return value ?? EMPTY_SOURCE_KEY;
+}
+
+function isExpired(expiresAt: number): boolean {
+  return expiresAt < Date.now();
+}
+
+function isStale(staleAt: number): boolean {
+  return staleAt < Date.now();
+}
+
+function sortRows(rows: ResourceCacheRow[]): ResourceCacheRow[] {
+  return [...rows].sort((a, b) => {
+    if (a.expires_at !== b.expires_at) return b.expires_at - a.expires_at;
+    if (a.stale_at !== b.stale_at) return b.stale_at - a.stale_at;
+    if (a.fetched_at !== b.fetched_at) return b.fetched_at - a.fetched_at;
+    return b.last_accessed_at - a.last_accessed_at;
+  });
+}
+
+export class ResourceStore {
+  constructor(private readonly db: Database) {}
+
+  private toCachedResource<T>(row: ResourceCacheRow): CachedResourceRecord<T> | null {
+    const value = safeParseJson<T>(row.payload);
+    if (value == null) return null;
+    return {
+      namespace: row.namespace,
+      kind: row.kind,
+      entityKey: row.entity_key,
+      variantKey: row.variant_key,
+      sourceKey: row.source_key,
+      value,
+      schemaVersion: row.schema_version,
+      provenance: safeParseJson<JsonValue>(row.provenance),
+      fetchedAt: row.fetched_at,
+      staleAt: row.stale_at,
+      expiresAt: row.expires_at,
+      lastAccessedAt: row.last_accessed_at,
+      sizeBytes: row.size_bytes,
+      stale: isStale(row.stale_at),
+      expired: isExpired(row.expires_at),
+    };
+  }
+
+  private deleteExact(key: ResourceCacheKey): void {
+    this.db
+      .query(
+        `DELETE FROM resource_cache
+         WHERE namespace = ? AND kind = ? AND entity_key = ? AND variant_key = ? AND source_key = ?`,
+      )
+      .run(
+        key.namespace,
+        key.kind,
+        key.entityKey,
+        normalizeVariantKey(key.variantKey),
+        normalizeSourceKey(key.sourceKey),
+      );
+  }
+
+  private touch(key: ResourceCacheKey): void {
+    this.db
+      .query(
+        `UPDATE resource_cache
+         SET last_accessed_at = ?
+         WHERE namespace = ? AND kind = ? AND entity_key = ? AND variant_key = ? AND source_key = ?`,
+      )
+      .run(
+        Date.now(),
+        key.namespace,
+        key.kind,
+        key.entityKey,
+        normalizeVariantKey(key.variantKey),
+        normalizeSourceKey(key.sourceKey),
+      );
+  }
+
+  private pruneIfNeeded(): void {
+    const stats = this.db
+      .query<{ count: number; total_size: number }, []>(
+        "SELECT COUNT(*) as count, COALESCE(SUM(size_bytes), 0) as total_size FROM resource_cache",
+      )
+      .get();
+    const count = stats?.count ?? 0;
+    const totalSize = stats?.total_size ?? 0;
+    if (count <= RESOURCE_CACHE_SOFT_ROW_LIMIT && totalSize <= RESOURCE_CACHE_SOFT_SIZE_LIMIT) return;
+
+    this.db.query("DELETE FROM resource_cache WHERE expires_at < ?").run(Date.now());
+
+    const remaining = this.db
+      .query<{ count: number; total_size: number }, []>(
+        "SELECT COUNT(*) as count, COALESCE(SUM(size_bytes), 0) as total_size FROM resource_cache",
+      )
+      .get();
+    const remainingCount = remaining?.count ?? 0;
+    const remainingSize = remaining?.total_size ?? 0;
+    if (remainingCount <= RESOURCE_CACHE_SOFT_ROW_LIMIT && remainingSize <= RESOURCE_CACHE_SOFT_SIZE_LIMIT) return;
+
+    const rowsToDelete = this.db
+      .query<{ namespace: string; kind: string; entity_key: string; variant_key: string; source_key: string }, [number]>(
+        `SELECT namespace, kind, entity_key, variant_key, source_key
+         FROM resource_cache
+         ORDER BY last_accessed_at ASC, fetched_at ASC
+         LIMIT ?`,
+      )
+      .all(Math.max(Math.ceil((remainingCount - RESOURCE_CACHE_SOFT_ROW_LIMIT) + 250), 250));
+
+    if (rowsToDelete.length === 0) return;
+    const remove = this.db.query(
+      `DELETE FROM resource_cache
+       WHERE namespace = ? AND kind = ? AND entity_key = ? AND variant_key = ? AND source_key = ?`,
+    );
+    const tx = this.db.transaction(() => {
+      for (const row of rowsToDelete) {
+        remove.run(row.namespace, row.kind, row.entity_key, row.variant_key, row.source_key);
+      }
+    });
+    tx();
+  }
+
+  get<T>(key: ResourceCacheKey, options: GetResourceOptions = {}): CachedResourceRecord<T> | null {
+    const row = this.db
+      .query<ResourceCacheRow, [string, string, string, string, string]>(
+        `SELECT namespace, kind, entity_key, variant_key, source_key, schema_version, payload, provenance,
+                fetched_at, stale_at, expires_at, last_accessed_at, size_bytes
+         FROM resource_cache
+         WHERE namespace = ? AND kind = ? AND entity_key = ? AND variant_key = ? AND source_key = ?`,
+      )
+      .get(
+        key.namespace,
+        key.kind,
+        key.entityKey,
+        normalizeVariantKey(key.variantKey),
+        normalizeSourceKey(key.sourceKey),
+      );
+
+    if (!row) return null;
+    if (!options.allowExpired && isExpired(row.expires_at)) return null;
+    if (options.schemaVersion != null && row.schema_version !== options.schemaVersion) {
+      this.deleteExact(key);
+      return null;
+    }
+
+    const record = this.toCachedResource<T>(row);
+    if (!record) {
+      this.deleteExact(key);
+      return null;
+    }
+
+    if (options.touch !== false) {
+      this.touch(key);
+      record.lastAccessedAt = Date.now();
+    }
+    return record;
+  }
+
+  list<T>(
+    key: Pick<ResourceCacheKey, "namespace" | "kind" | "entityKey">,
+    options: ListResourceOptions = {},
+  ): CachedResourceRecord<T>[] {
+    const rows = this.db
+      .query<ResourceCacheRow, [string, string, string]>(
+        `SELECT namespace, kind, entity_key, variant_key, source_key, schema_version, payload, provenance,
+                fetched_at, stale_at, expires_at, last_accessed_at, size_bytes
+         FROM resource_cache
+         WHERE namespace = ? AND kind = ? AND entity_key = ?`,
+      )
+      .all(key.namespace, key.kind, key.entityKey);
+
+    const allowedVariantKeys = options.variantKeys ? new Set(options.variantKeys.map(normalizeVariantKey)) : null;
+    const allowedSourceKeys = options.sourceKeys ? new Set(options.sourceKeys.map(normalizeSourceKey)) : null;
+
+    const records: CachedResourceRecord<T>[] = [];
+    for (const row of sortRows(rows)) {
+      if (!options.allowExpired && isExpired(row.expires_at)) continue;
+      if (allowedVariantKeys && !allowedVariantKeys.has(row.variant_key)) continue;
+      if (allowedSourceKeys && !allowedSourceKeys.has(row.source_key)) continue;
+      if (options.schemaVersion != null && row.schema_version !== options.schemaVersion) {
+        this.deleteExact({
+          namespace: row.namespace,
+          kind: row.kind,
+          entityKey: row.entity_key,
+          variantKey: row.variant_key,
+          sourceKey: row.source_key,
+        });
+        continue;
+      }
+      const record = this.toCachedResource<T>(row);
+      if (!record) {
+        this.deleteExact({
+          namespace: row.namespace,
+          kind: row.kind,
+          entityKey: row.entity_key,
+          variantKey: row.variant_key,
+          sourceKey: row.source_key,
+        });
+        continue;
+      }
+      records.push(record);
+    }
+    return records;
+  }
+
+  set<T>(key: ResourceCacheKey, value: T, options: SetResourceOptions): CachedResourceRecord<T> {
+    const now = options.fetchedAt ?? Date.now();
+    const payload = serializeJson(value);
+    const provenance = options.provenance == null ? null : serializeJson(options.provenance);
+    const rowKey = {
+      namespace: key.namespace,
+      kind: key.kind,
+      entityKey: key.entityKey,
+      variantKey: normalizeVariantKey(key.variantKey),
+      sourceKey: normalizeSourceKey(key.sourceKey),
+    };
+
+    this.db
+      .query(
+        `INSERT OR REPLACE INTO resource_cache (
+          namespace, kind, entity_key, variant_key, source_key, schema_version,
+          payload, provenance, fetched_at, stale_at, expires_at, last_accessed_at, size_bytes
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        rowKey.namespace,
+        rowKey.kind,
+        rowKey.entityKey,
+        rowKey.variantKey,
+        rowKey.sourceKey,
+        options.schemaVersion ?? DEFAULT_RESOURCE_SCHEMA_VERSION,
+        payload,
+        provenance,
+        now,
+        now + options.cachePolicy.staleMs,
+        now + options.cachePolicy.expireMs,
+        now,
+        Buffer.byteLength(payload, "utf8"),
+      );
+
+    this.pruneIfNeeded();
+    return this.get<T>(rowKey, { allowExpired: true, touch: false })!;
+  }
+
+  delete(key: ResourceCacheKey): void {
+    this.deleteExact(key);
+  }
+
+  clear(namespace?: string): void {
+    if (!namespace) {
+      this.db.query("DELETE FROM resource_cache").run();
+      return;
+    }
+    this.db.query("DELETE FROM resource_cache WHERE namespace = ?").run(namespace);
+  }
+}

package/src/data/session-store.ts

@@ -0,0 +1,52 @@
+import type { Database } from "bun:sqlite";
+import { safeParseJson, serializeJson } from "./sqlite-json";
+
+export const DEFAULT_SESSION_SCHEMA_VERSION = 1;
+
+export interface SessionSnapshotRecord<T = unknown> {
+  sessionId: string;
+  value: T;
+  schemaVersion: number;
+  updatedAt: number;
+}
+
+export class SessionStore {
+  constructor(private readonly db: Database) {}
+
+  get<T>(sessionId = "app", schemaVersion = DEFAULT_SESSION_SCHEMA_VERSION): SessionSnapshotRecord<T> | null {
+    const row = this.db
+      .query<{ schema_version: number; value: string; updated_at: number }, [string]>(
+        "SELECT schema_version, value, updated_at FROM session_snapshots WHERE session_id = ?",
+      )
+      .get(sessionId);
+    if (!row) return null;
+    if (row.schema_version !== schemaVersion) {
+      this.delete(sessionId);
+      return null;
+    }
+    const value = safeParseJson<T>(row.value);
+    if (value == null) {
+      this.delete(sessionId);
+      return null;
+    }
+    return {
+      sessionId,
+      value,
+      schemaVersion: row.schema_version,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  set(sessionId: string, value: unknown, schemaVersion = DEFAULT_SESSION_SCHEMA_VERSION): void {
+    this.db
+      .query(
+        `INSERT OR REPLACE INTO session_snapshots (session_id, schema_version, value, updated_at)
+         VALUES (?, ?, ?, ?)`,
+      )
+      .run(sessionId, schemaVersion, serializeJson(value), Date.now());
+  }
+
+  delete(sessionId: string): void {
+    this.db.query("DELETE FROM session_snapshots WHERE session_id = ?").run(sessionId);
+  }
+}

package/src/data/sqlite-cache.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { AppPersistence } from "./app-persistence";
+
+const tempPaths: string[] = [];
+
+function createTempDbPath(name: string): string {
+  const path = join(tmpdir(), `gloomberb-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  tempPaths.push(path);
+  return path;
+}
+
+afterEach(() => {
+  for (const path of tempPaths.splice(0)) {
+    if (existsSync(path)) rmSync(path, { force: true });
+  }
+});
+
+describe("AppPersistence", () => {
+  test("stores and returns cached resources", () => {
+    const dbPath = createTempDbPath("resource-cache");
+    const persistence = new AppPersistence(dbPath);
+    persistence.resources.set({
+      namespace: "market",
+      kind: "quote",
+      entityKey: "AAPL",
+      sourceKey: "provider:yahoo",
+    }, {
+      price: 123,
+    }, {
+      cachePolicy: { staleMs: 60_000, expireMs: 120_000 },
+      schemaVersion: 1,
+    });
+
+    expect(persistence.resources.get<{ price: number }>({
+      namespace: "market",
+      kind: "quote",
+      entityKey: "AAPL",
+      sourceKey: "provider:yahoo",
+    }, { allowExpired: true })?.value.price).toBe(123);
+    persistence.close();
+  });
+
+  test("invalidates plugin state when schema versions differ", () => {
+    const dbPath = createTempDbPath("plugin-version");
+    const persistence = new AppPersistence(dbPath);
+    persistence.pluginState.set("ai", "conversation", { messages: ["hello"] }, 2);
+
+    expect(persistence.pluginState.get("ai", "conversation", 1)).toBeNull();
+    expect(persistence.pluginState.get("ai", "conversation", 2)).toBeNull();
+    persistence.close();
+  });
+
+  test("returns a stable plugin state snapshot until the row changes", () => {
+    const dbPath = createTempDbPath("plugin-snapshot-cache");
+    const persistence = new AppPersistence(dbPath);
+    persistence.pluginState.set("ai", "resume:screener-pane:test", {
+      tabs: [{ id: "1", prompt: "durable compounders" }],
+    }, 1);
+
+    const first = persistence.pluginState.get<{ tabs: Array<{ id: string; prompt: string }> }>("ai", "resume:screener-pane:test", 1);
+    const second = persistence.pluginState.get<{ tabs: Array<{ id: string; prompt: string }> }>("ai", "resume:screener-pane:test", 1);
+
+    expect(first).not.toBeNull();
+    expect(second).not.toBeNull();
+    expect(second).toBe(first);
+
+    persistence.pluginState.set("ai", "resume:screener-pane:test", {
+      tabs: [{ id: "2", prompt: "new leaders" }],
+    }, 1);
+    const third = persistence.pluginState.get<{ tabs: Array<{ id: string; prompt: string }> }>("ai", "resume:screener-pane:test", 1);
+
+    expect(third).not.toBeNull();
+    expect(third).not.toBe(first);
+    expect(third?.value.tabs[0]?.id).toBe("2");
+    persistence.close();
+  });
+
+  test("returns stable references for unchanged plugin state snapshots", () => {
+    const dbPath = createTempDbPath("plugin-stable-snapshot");
+    const persistence = new AppPersistence(dbPath);
+    persistence.pluginState.set("prediction-markets", "resume:watchlist:v1", ["kalshi:ABC"], 1);
+
+    const first = persistence.pluginState.get<string[]>("prediction-markets", "resume:watchlist:v1", 1);
+    const second = persistence.pluginState.get<string[]>("prediction-markets", "resume:watchlist:v1", 1);
+
+    expect(first).not.toBeNull();
+    expect(second).not.toBeNull();
+    expect(second?.value).toBe(first?.value);
+    persistence.close();
+  });
+
+  test("stores and returns session snapshots", () => {
+    const dbPath = createTempDbPath("session-snapshot");
+    const persistence = new AppPersistence(dbPath);
+    persistence.sessions.set("app", { focusedPaneId: "ticker-detail:main" }, 1);
+
+    expect(persistence.sessions.get<{ focusedPaneId: string }>("app", 1)?.value.focusedPaneId).toBe("ticker-detail:main");
+    persistence.close();
+  });
+});

package/src/data/sqlite-database.ts

@@ -0,0 +1,62 @@
+import { Database } from "bun:sqlite";
+
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS tickers (
+    symbol TEXT PRIMARY KEY,
+    metadata TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS resource_cache (
+    namespace TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    entity_key TEXT NOT NULL,
+    variant_key TEXT NOT NULL DEFAULT '',
+    source_key TEXT NOT NULL DEFAULT '',
+    schema_version INTEGER NOT NULL,
+    payload TEXT NOT NULL,
+    provenance TEXT,
+    fetched_at INTEGER NOT NULL,
+    stale_at INTEGER NOT NULL,
+    expires_at INTEGER NOT NULL,
+    last_accessed_at INTEGER NOT NULL,
+    size_bytes INTEGER NOT NULL,
+    PRIMARY KEY (namespace, kind, entity_key, variant_key, source_key)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_resource_cache_lookup
+    ON resource_cache (namespace, kind, entity_key, expires_at, stale_at);
+
+  CREATE INDEX IF NOT EXISTS idx_resource_cache_lru
+    ON resource_cache (expires_at, last_accessed_at);
+
+  CREATE TABLE IF NOT EXISTS plugin_state (
+    plugin_id TEXT NOT NULL,
+    key TEXT NOT NULL,
+    schema_version INTEGER NOT NULL,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL,
+    PRIMARY KEY (plugin_id, key)
+  );
+
+  CREATE TABLE IF NOT EXISTS session_snapshots (
+    session_id TEXT PRIMARY KEY,
+    schema_version INTEGER NOT NULL,
+    value TEXT NOT NULL,
+    updated_at INTEGER NOT NULL
+  );
+`;
+
+export class SqliteDatabase {
+  readonly connection: Database;
+
+  constructor(dbPath: string) {
+    this.connection = new Database(dbPath);
+    this.connection.exec("PRAGMA journal_mode=WAL");
+    this.connection.exec(SCHEMA);
+  }
+
+  close(): void {
+    this.connection.close();
+  }
+}

package/src/data/sqlite-json.ts

@@ -0,0 +1,19 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
+
+export function serializeJson(value: unknown): string {
+  return JSON.stringify(value);
+}
+
+export function parseJson<T>(value: string): T {
+  return JSON.parse(value) as T;
+}
+
+export function safeParseJson<T>(value: string | null): T | null {
+  if (!value) return null;
+  try {
+    return parseJson<T>(value);
+  } catch {
+    return null;
+  }
+}

package/src/data/ticker-repository.ts

@@ -0,0 +1,45 @@
+import type { TickerRecord, TickerMetadata } from "../types/ticker";
+import type { TickerStore } from "./ticker-store";
+import { hydrateTickerMetadata } from "../utils/ticker-metadata";
+
+function parseTickerMetadata(json: string): TickerMetadata {
+  return hydrateTickerMetadata(JSON.parse(json) as Record<string, unknown>);
+}
+
+export class TickerRepository {
+  constructor(private readonly tickers: TickerStore) {}
+
+  async loadAllTickers(): Promise<TickerRecord[]> {
+    return this.tickers.getAll().flatMap((row) => {
+      try {
+        return [{ metadata: parseTickerMetadata(row.metadata) }];
+      } catch {
+        return [];
+      }
+    });
+  }
+
+  async loadTicker(symbol: string): Promise<TickerRecord | null> {
+    const json = this.tickers.get(symbol);
+    if (!json) return null;
+    try {
+      return { metadata: parseTickerMetadata(json) };
+    } catch {
+      return null;
+    }
+  }
+
+  async saveTicker(ticker: TickerRecord): Promise<void> {
+    this.tickers.save(ticker.metadata.ticker, ticker.metadata);
+  }
+
+  async createTicker(metadata: TickerMetadata): Promise<TickerRecord> {
+    const ticker: TickerRecord = { metadata };
+    await this.saveTicker(ticker);
+    return ticker;
+  }
+
+  async deleteTicker(symbol: string): Promise<void> {
+    this.tickers.delete(symbol);
+  }
+}

package/src/data/ticker-store.ts

@@ -0,0 +1,46 @@
+import type { Database } from "bun:sqlite";
+import { serializeJson } from "./sqlite-json";
+
+export interface StoredTickerRecord {
+  symbol: string;
+  metadata: string;
+}
+
+export class TickerStore {
+  constructor(private readonly db: Database) {}
+
+  getAll(): StoredTickerRecord[] {
+    return this.db
+      .query<StoredTickerRecord, []>(
+        "SELECT symbol, metadata FROM tickers ORDER BY symbol",
+      )
+      .all();
+  }
+
+  get(symbol: string): string | null {
+    const row = this.db
+      .query<{ metadata: string }, [string]>(
+        "SELECT metadata FROM tickers WHERE symbol = ?",
+      )
+      .get(symbol);
+    return row?.metadata ?? null;
+  }
+
+  save(symbol: string, metadata: unknown): void {
+    this.db
+      .query(
+        `INSERT OR REPLACE INTO tickers (symbol, metadata, updated_at)
+         VALUES (?, ?, ?)`,
+      )
+      .run(symbol, serializeJson(metadata), Date.now());
+  }
+
+  delete(symbol: string): void {
+    this.db.query("DELETE FROM tickers WHERE symbol = ?").run(symbol);
+  }
+
+  count(): number {
+    const row = this.db.query<{ count: number }, []>("SELECT COUNT(*) as count FROM tickers").get();
+    return row?.count ?? 0;
+  }
+}