@vaultgradient/pipequery-cli 0.3.2

package/src/server/sources/file.ts

@@ -0,0 +1,79 @@
+import { readFile } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import { watch } from 'chokidar';
+import { parse as csvParse } from 'csv-parse/sync';
+import type { FileSourceConfig } from '../../config/schema.js';
+import type { SourceAdapter, SourceStatus } from './types.js';
+
+export class FileSourceAdapter implements SourceAdapter {
+  private data: unknown[] = [];
+  private watcher: ReturnType<typeof watch> | null = null;
+  private lastFetch: Date | null = null;
+  private error?: string;
+  private listeners = new Set<(data: unknown[]) => void>();
+  private resolvedPath: string;
+
+  constructor(private config: FileSourceConfig, private cwd: string) {
+    this.resolvedPath = resolve(cwd, config.path);
+  }
+
+  async start(): Promise<void> {
+    await this.load();
+    if (this.config.watch) {
+      this.watcher = watch(this.resolvedPath, { ignoreInitial: true });
+      this.watcher.on('change', () => this.load());
+    }
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+  }
+
+  getData(): unknown[] {
+    return this.data;
+  }
+
+  getStatus(): SourceStatus {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error,
+    };
+  }
+
+  onUpdate(callback: (data: unknown[]) => void): () => void {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+
+  private async load(): Promise<void> {
+    try {
+      const content = await readFile(this.resolvedPath, 'utf-8');
+      const format = this.config.format ?? this.detectFormat();
+
+      if (format === 'csv') {
+        this.data = csvParse(content, { columns: true, skip_empty_lines: true, cast: true });
+      } else {
+        const parsed = JSON.parse(content);
+        this.data = Array.isArray(parsed) ? parsed : [parsed];
+      }
+
+      this.lastFetch = new Date();
+      this.error = undefined;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  private detectFormat(): 'json' | 'csv' {
+    const ext = extname(this.resolvedPath).toLowerCase();
+    return ext === '.csv' || ext === '.tsv' ? 'csv' : 'json';
+  }
+
+  private notify(): void {
+    for (const cb of this.listeners) cb(this.data);
+  }
+}

package/src/server/sources/manager.ts

@@ -0,0 +1,120 @@
+import type { SourceConfig } from '../../config/schema.js';
+import type { SourceAdapter, SourceStatus } from './types.js';
+import { RestSourceAdapter } from './rest.js';
+import { WebSocketSourceAdapter } from './websocket.js';
+import { FileSourceAdapter } from './file.js';
+import { StaticSourceAdapter } from './static.js';
+
+export type DataContext = Record<string, unknown[]>;
+
+type UpdateListener = (sourceName: string, data: unknown[]) => void;
+
+interface ManagedSource {
+  config: SourceConfig;
+  adapter: SourceAdapter;
+  unsubscribe?: () => void;
+}
+
+export class SourceManager {
+  private sources = new Map<string, ManagedSource>();
+  private globalListeners = new Set<UpdateListener>();
+
+  constructor(private cwd: string) {}
+
+  async addSource(name: string, config: SourceConfig): Promise<void> {
+    // Stop existing source with same name if present
+    if (this.sources.has(name)) {
+      this.removeSource(name);
+    }
+
+    const adapter = this.createAdapter(config);
+    const entry: ManagedSource = { config, adapter };
+
+    // Subscribe to updates and notify global listeners
+    entry.unsubscribe = adapter.onUpdate((data) => {
+      for (const listener of this.globalListeners) {
+        listener(name, data);
+      }
+    });
+
+    this.sources.set(name, entry);
+    await adapter.start();
+  }
+
+  removeSource(name: string): boolean {
+    const entry = this.sources.get(name);
+    if (!entry) return false;
+    entry.unsubscribe?.();
+    entry.adapter.stop();
+    this.sources.delete(name);
+    return true;
+  }
+
+  getContext(): DataContext {
+    const ctx: DataContext = {};
+    for (const [name, { adapter }] of this.sources) {
+      ctx[name] = adapter.getData();
+    }
+    return ctx;
+  }
+
+  getSourceData(name: string): unknown[] | undefined {
+    return this.sources.get(name)?.adapter.getData();
+  }
+
+  getSourceStatus(name: string): SourceStatus | undefined {
+    return this.sources.get(name)?.adapter.getStatus();
+  }
+
+  getAllStatuses(): Record<string, SourceStatus> {
+    const result: Record<string, SourceStatus> = {};
+    for (const [name, { adapter }] of this.sources) {
+      result[name] = adapter.getStatus();
+    }
+    return result;
+  }
+
+  getSourceNames(): string[] {
+    return [...this.sources.keys()];
+  }
+
+  /**
+   * Subscribe to data updates from any source.
+   * Used by SSE endpoint for real-time push to TUI clients.
+   * Returns unsubscribe function.
+   */
+  onSourceUpdate(callback: UpdateListener): () => void {
+    this.globalListeners.add(callback);
+    return () => this.globalListeners.delete(callback);
+  }
+
+  async refreshAll(): Promise<void> {
+    await Promise.all(
+      [...this.sources.values()].map(({ adapter }) => adapter.refresh?.() ?? Promise.resolve()),
+    );
+  }
+
+  async dispose(): Promise<void> {
+    this.globalListeners.clear();
+    for (const entry of this.sources.values()) {
+      entry.unsubscribe?.();
+      entry.adapter.stop();
+    }
+    this.sources.clear();
+  }
+
+  private createAdapter(config: SourceConfig): SourceAdapter {
+    switch (config.type) {
+      case 'rest':
+        return new RestSourceAdapter(config);
+      case 'websocket':
+        return new WebSocketSourceAdapter(config);
+      case 'file':
+        return new FileSourceAdapter(config, this.cwd);
+      case 'static':
+        return new StaticSourceAdapter(config);
+      default:
+        throw new Error(`Unknown source type: ${(config as { type: string }).type}`);
+    }
+  }
+}

package/src/server/sources/rest.ts

@@ -0,0 +1,85 @@
+import type { RestSourceConfig } from '../../config/schema.js';
+import { parseDuration } from '../../utils/parseDuration.js';
+import type { SourceAdapter, SourceStatus } from './types.js';
+
+function extractPath(obj: unknown, path: string): unknown[] {
+  let current: unknown = obj;
+  for (const key of path.split('.')) {
+    if (current == null || typeof current !== 'object') return [];
+    current = (current as Record<string, unknown>)[key];
+  }
+  return Array.isArray(current) ? current : [];
+}
+
+export class RestSourceAdapter implements SourceAdapter {
+  private data: unknown[] = [];
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastFetch: Date | null = null;
+  private error?: string;
+  private listeners = new Set<(data: unknown[]) => void>();
+
+  constructor(private config: RestSourceConfig) {}
+
+  async start(): Promise<void> {
+    await this.fetch();
+    const interval = this.config.interval ? parseDuration(this.config.interval) : 30_000;
+    this.timer = setInterval(() => this.fetch(), interval);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  getData(): unknown[] {
+    return this.data;
+  }
+
+  getStatus(): SourceStatus {
+    return {
+      healthy: !this.error,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error,
+    };
+  }
+
+  onUpdate(callback: (data: unknown[]) => void): () => void {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+
+  async refresh(): Promise<void> {
+    await this.fetch();
+  }
+
+  private async fetch(): Promise<void> {
+    try {
+      let url = this.config.url;
+      if (this.config.params) {
+        const params = new URLSearchParams(this.config.params);
+        url += (url.includes('?') ? '&' : '?') + params.toString();
+      }
+
+      const res = await globalThis.fetch(url, {
+        headers: this.config.headers,
+      });
+
+      if (!res.ok) throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+
+      const json = await res.json();
+      this.data = this.config.dataPath ? extractPath(json, this.config.dataPath) : (Array.isArray(json) ? json : [json]);
+      this.lastFetch = new Date();
+      this.error = undefined;
+      this.notify();
+    } catch (err) {
+      this.error = err instanceof Error ? err.message : String(err);
+    }
+  }
+
+  private notify(): void {
+    for (const cb of this.listeners) cb(this.data);
+  }
+}

package/src/server/sources/static.ts

@@ -0,0 +1,31 @@
+import type { StaticSourceConfig } from '../../config/schema.js';
+import type { SourceAdapter, SourceStatus } from './types.js';
+
+export class StaticSourceAdapter implements SourceAdapter {
+  private listeners = new Set<(data: unknown[]) => void>();
+
+  constructor(private config: StaticSourceConfig) {}
+
+  async start(): Promise<void> {
+    // Static data is immediately available
+  }
+
+  stop(): void {}
+
+  getData(): unknown[] {
+    return this.config.data;
+  }
+
+  getStatus(): SourceStatus {
+    return {
+      healthy: true,
+      rowCount: this.config.data.length,
+      lastFetch: new Date(),
+    };
+  }
+
+  onUpdate(callback: (data: unknown[]) => void): () => void {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+}

package/src/server/sources/types.ts

@@ -0,0 +1,15 @@
+export interface SourceStatus {
+  healthy: boolean;
+  rowCount: number;
+  lastFetch: Date | null;
+  error?: string;
+}
+
+export interface SourceAdapter {
+  start(): Promise<void>;
+  stop(): void;
+  getData(): unknown[];
+  getStatus(): SourceStatus;
+  onUpdate(callback: (data: unknown[]) => void): () => void;
+  refresh?(): Promise<void>;
+}

package/src/server/sources/websocket.ts

@@ -0,0 +1,86 @@
+import WebSocket from 'ws';
+import type { WebSocketSourceConfig } from '../../config/schema.js';
+import type { SourceAdapter, SourceStatus } from './types.js';
+
+export class WebSocketSourceAdapter implements SourceAdapter {
+  private data: unknown[] = [];
+  private ws: WebSocket | null = null;
+  private lastFetch: Date | null = null;
+  private error?: string;
+  private listeners = new Set<(data: unknown[]) => void>();
+  private maxBuffer: number;
+
+  constructor(private config: WebSocketSourceConfig) {
+    this.maxBuffer = config.maxBuffer ?? 1000;
+  }
+
+  async start(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.config.url);
+
+      this.ws.on('open', () => {
+        this.error = undefined;
+        resolve();
+      });
+
+      this.ws.on('message', (raw) => {
+        try {
+          const parsed = JSON.parse(raw.toString());
+          if (Array.isArray(parsed)) {
+            this.data = parsed;
+          } else {
+            this.data.push(parsed);
+            if (this.data.length > this.maxBuffer) {
+              this.data = this.data.slice(-this.maxBuffer);
+            }
+          }
+          this.lastFetch = new Date();
+          this.error = undefined;
+          this.notify();
+        } catch {
+          // ignore non-JSON messages
+        }
+      });
+
+      this.ws.on('error', (err) => {
+        this.error = err.message;
+        reject(err);
+      });
+
+      this.ws.on('close', () => {
+        // Auto-reconnect after 5s
+        setTimeout(() => {
+          if (this.ws) this.start().catch(() => {});
+        }, 5000);
+      });
+    });
+  }
+
+  stop(): void {
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close();
+  }
+
+  getData(): unknown[] {
+    return this.data;
+  }
+
+  getStatus(): SourceStatus {
+    return {
+      healthy: this.ws?.readyState === WebSocket.OPEN,
+      rowCount: this.data.length,
+      lastFetch: this.lastFetch,
+      error: this.error,
+    };
+  }
+
+  onUpdate(callback: (data: unknown[]) => void): () => void {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+
+  private notify(): void {
+    for (const cb of this.listeners) cb(this.data);
+  }
+}

package/src/tui/App.tsx

@@ -0,0 +1,141 @@
+import React, { useState, useMemo, useCallback } from 'react';
+import { Box, Text, useStdout } from 'ink';
+import type { DashboardConfig, PanelConfig } from '../config/schema.js';
+import { parseDuration } from '../utils/parseDuration.js';
+import { useLiveData } from './hooks/useLiveData.js';
+import { useKeyboard } from './hooks/useKeyboard.js';
+import { Panel } from './components/Panel.js';
+import { Table } from './components/Table.js';
+import { BarChart } from './components/BarChart.js';
+import { StatBox } from './components/StatBox.js';
+import { Sparkline } from './components/Sparkline.js';
+import { OrderBook } from './components/OrderBook.js';
+import { Heatmap } from './components/Heatmap.js';
+import { CandleChart } from './components/CandleChart.js';
+import { Layout } from './components/Layout.js';
+import { StatusBar } from './components/StatusBar.js';
+
+interface AppProps {
+  serverUrl: string;
+  dashboard: DashboardConfig;
+}
+
+const MemoizedPanelContent = React.memo(function PanelContent({ data, error, viz, focused, loading, panelKey, maxTableRows }: {
+  data: unknown;
+  error?: string;
+  viz: string;
+  focused: boolean;
+  loading: boolean;
+  panelKey: string;
+  maxTableRows: number;
+}) {
+  if (error) return <Text color="red">{error}</Text>;
+  if (loading || data == null) return <Text dimColor>Loading...</Text>;
+
+  const rows = Array.isArray(data) ? data as Record<string, unknown>[] : [];
+
+  switch (viz) {
+    case 'bar':
+      return <BarChart data={rows} />;
+    case 'stat':
+      return <StatBox data={data} />;
+    case 'sparkline':
+      return <Sparkline data={rows} />;
+    case 'orderbook':
+      return <OrderBook data={data} />;
+    case 'heatmap':
+      return <Heatmap data={rows} />;
+    case 'candle':
+      return <CandleChart data={Array.isArray(data) ? data : []} />;
+    case 'table':
+      return <Table data={rows} focused={focused} maxRows={maxTableRows} />;
+    case 'auto':
+    default:
+      if (!Array.isArray(data) || rows.length === 0) return <StatBox data={data} />;
+      return <Table data={rows} focused={focused} maxRows={maxTableRows} />;
+  }
+});
+
+export function App({ serverUrl, dashboard }: AppProps) {
+  const [focusedPanel, setFocusedPanel] = useState(0);
+  const { stdout } = useStdout();
+  const termHeight = stdout?.rows ?? 40;
+  const panels = dashboard.panels;
+  const refreshMs = dashboard.refresh ? parseDuration(dashboard.refresh) : 10_000;
+
+  // Column weights: each panel gets a width percentage (default 50% each)
+  const [colWeights, setColWeights] = useState<number[]>(() =>
+    panels.map(() => 50),
+  );
+
+  const fixedOverhead = 3; // header + status bar
+  const numPanelRows = Math.ceil(panels.length / 2);
+  const rowHeight = Math.max(8, Math.floor((termHeight - fixedOverhead) / numPanelRows));
+  const panelOverhead = 5; // border + title + padding
+  const maxTableRows = Math.max(3, rowHeight - panelOverhead);
+
+  const queries = useMemo(() => panels.map((p) => p.query), [panels]);
+  // Use SSE for real-time push, with polling fallback
+  const { results, loading, connected, refresh } = useLiveData(serverUrl, queries, refreshMs);
+
+  // Resize handler: grow/shrink focused panel, adjust its row neighbor
+  const handleResize = useCallback((direction: 'grow' | 'shrink') => {
+    setColWeights(prev => {
+      const next = [...prev];
+      const rowStart = Math.floor(focusedPanel / 2) * 2;
+      const partner = focusedPanel % 2 === 0 ? focusedPanel + 1 : focusedPanel - 1;
+      if (partner < 0 || partner >= panels.length) return prev;
+      if (partner < rowStart || partner >= rowStart + 2) return prev;
+      const delta = direction === 'grow' ? 5 : -5;
+      const newVal = Math.min(75, Math.max(25, next[focusedPanel] + delta));
+      next[focusedPanel] = newVal;
+      next[partner] = 100 - newVal;
+      return next;
+    });
+  }, [focusedPanel, panels.length]);
+
+  useKeyboard({
+    panelCount: panels.length,
+    focusedPanel,
+    setFocusedPanel,
+    onRefresh: refresh,
+    onResize: handleResize,
+  });
+
+  const renderPanel = useCallback((panel: PanelConfig, index: number, focused: boolean) => {
+    const result = results.get(panel.query);
+    return (
+      <Panel title={panel.title} focused={focused}>
+        <MemoizedPanelContent
+          panelKey={`panel-${index}`}
+          data={result?.data ?? null}
+          error={result?.error}
+          viz={panel.viz}
+          focused={focused}
+          loading={loading && !result}
+          maxTableRows={maxTableRows}
+        />
+      </Panel>
+    );
+  }, [results, loading, maxTableRows]);
+
+  return (
+    <Box flexDirection="column" height={termHeight}>
+      <Box justifyContent="center" paddingX={1}>
+        <Text bold color="cyan">PipeQuery Dashboard</Text>
+        {connected && <Text color="green"> ● LIVE</Text>}
+        {!connected && !loading && <Text color="yellow"> ○ polling</Text>}
+      </Box>
+      <Box flexDirection="column" flexGrow={1} overflow="hidden">
+        <Layout
+          panels={panels}
+          focusedIndex={focusedPanel}
+          colWeights={colWeights}
+          rowHeight={rowHeight}
+          renderPanel={renderPanel}
+        />
+      </Box>
+      <StatusBar serverUrl={serverUrl} refreshMs={refreshMs} />
+    </Box>
+  );
+}