@jhytabest/plashboard 0.1.0

package/src/stores.ts

@@ -0,0 +1,127 @@
+import { readdir, rm } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import type { DashboardTemplate, PlashboardConfig, PlashboardState, RunArtifact } from './types.js';
+import { atomicWriteJson, ensureDir, readJsonFile } from './utils.js';
+
+function emptyState(): PlashboardState {
+  return {
+    version: 1,
+    active_template_id: null,
+    template_runs: {}
+  };
+}
+
+export class Paths {
+  readonly dataDir: string;
+  readonly statePath: string;
+  readonly templatesDir: string;
+  readonly runsDir: string;
+  readonly renderedDir: string;
+  readonly liveDashboardPath: string;
+
+  constructor(config: PlashboardConfig) {
+    this.dataDir = config.data_dir;
+    this.statePath = join(this.dataDir, 'state.json');
+    this.templatesDir = join(this.dataDir, 'templates');
+    this.runsDir = join(this.dataDir, 'runs');
+    this.renderedDir = join(this.dataDir, 'rendered');
+    this.liveDashboardPath = config.dashboard_output_path;
+  }
+
+  async ensure(): Promise<void> {
+    await Promise.all([
+      ensureDir(this.dataDir),
+      ensureDir(this.templatesDir),
+      ensureDir(this.runsDir),
+      ensureDir(this.renderedDir)
+    ]);
+  }
+}
+
+export class StateStore {
+  constructor(private readonly paths: Paths) {}
+
+  async load(): Promise<PlashboardState> {
+    const value = await readJsonFile<PlashboardState>(this.paths.statePath);
+    if (!value) {
+      return emptyState();
+    }
+    return {
+      version: 1,
+      active_template_id: value.active_template_id ?? null,
+      template_runs: value.template_runs ?? {},
+      display_profile: value.display_profile
+    };
+  }
+
+  async save(state: PlashboardState): Promise<void> {
+    await atomicWriteJson(this.paths.statePath, state);
+  }
+}
+
+export class TemplateStore {
+  constructor(private readonly paths: Paths) {}
+
+  pathForId(templateId: string): string {
+    return join(this.paths.templatesDir, `${templateId}.json`);
+  }
+
+  async list(): Promise<DashboardTemplate[]> {
+    await ensureDir(this.paths.templatesDir);
+    const entries = await readdir(this.paths.templatesDir, { withFileTypes: true });
+    const templates: DashboardTemplate[] = [];
+
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+      const fullPath = join(this.paths.templatesDir, entry.name);
+      const loaded = await readJsonFile<DashboardTemplate>(fullPath);
+      if (!loaded) continue;
+      templates.push(loaded);
+    }
+
+    templates.sort((a, b) => a.id.localeCompare(b.id));
+    return templates;
+  }
+
+  async get(templateId: string): Promise<DashboardTemplate | null> {
+    return readJsonFile<DashboardTemplate>(this.pathForId(templateId));
+  }
+
+  async upsert(template: DashboardTemplate): Promise<void> {
+    await atomicWriteJson(this.pathForId(template.id), template);
+  }
+
+  async remove(templateId: string): Promise<void> {
+    await rm(this.pathForId(templateId), { force: true });
+  }
+}
+
+export class RunStore {
+  constructor(private readonly paths: Paths) {}
+
+  async write(templateId: string, artifact: RunArtifact): Promise<string> {
+    const safeTimestamp = artifact.started_at.replaceAll(':', '-');
+    const dir = join(this.paths.runsDir, templateId);
+    await ensureDir(dir);
+    const filePath = join(dir, `${safeTimestamp}.json`);
+    await atomicWriteJson(filePath, artifact);
+    return filePath;
+  }
+
+  async latestByTemplate(templateId: string, limit = 10): Promise<RunArtifact[]> {
+    const dir = join(this.paths.runsDir, templateId);
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const files = entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+      .map((entry) => join(dir, entry.name))
+      .sort((a, b) => basename(b).localeCompare(basename(a)))
+      .slice(0, limit);
+
+    const output: RunArtifact[] = [];
+    for (const file of files) {
+      const loaded = await readJsonFile<RunArtifact>(file);
+      if (loaded) output.push(loaded);
+    }
+    return output;
+  }
+}

package/src/types.ts

@@ -0,0 +1,139 @@
+export type FillFieldType = 'string' | 'number' | 'boolean' | 'array';
+
+export interface DisplayProfile {
+  width_px: number;
+  height_px: number;
+  safe_top_px: number;
+  safe_bottom_px: number;
+  safe_side_px: number;
+  layout_safety_margin_px: number;
+}
+
+export interface ModelDefaults {
+  model?: string;
+  temperature?: number;
+  max_tokens?: number;
+}
+
+export interface PlashboardConfig {
+  data_dir: string;
+  timezone: string;
+  scheduler_tick_seconds: number;
+  max_parallel_runs: number;
+  default_retry_count: number;
+  retry_backoff_seconds: number;
+  session_timeout_seconds: number;
+  fill_provider: 'command' | 'mock';
+  fill_command?: string;
+  python_bin: string;
+  writer_script_path: string;
+  dashboard_output_path: string;
+  layout_overflow_tolerance_px: number;
+  display_profile: DisplayProfile;
+  model_defaults: ModelDefaults;
+}
+
+export interface TemplateSchedule {
+  mode: 'interval';
+  every_minutes: number;
+  timezone: string;
+}
+
+export interface TemplateContext {
+  dashboard_prompt?: string;
+  section_prompts?: Record<string, string>;
+  card_prompts?: Record<string, string>;
+}
+
+export interface FieldConstraints {
+  max_len?: number;
+  min?: number;
+  max?: number;
+  enum?: Array<string | number | boolean>;
+  min_items?: number;
+  max_items?: number;
+}
+
+export interface FieldSpec {
+  id: string;
+  pointer: string;
+  type: FillFieldType;
+  prompt: string;
+  required?: boolean;
+  constraints?: FieldConstraints;
+}
+
+export interface TemplateRunConfig {
+  retry_count?: number;
+  repair_attempts?: number;
+  model?: string;
+  temperature?: number;
+  max_tokens?: number;
+}
+
+export interface DashboardTemplate {
+  id: string;
+  name: string;
+  enabled: boolean;
+  schedule: TemplateSchedule;
+  base_dashboard: Record<string, unknown>;
+  fields: FieldSpec[];
+  context?: TemplateContext;
+  run?: TemplateRunConfig;
+}
+
+export interface TemplateRunState {
+  last_attempt_at?: string;
+  last_success_at?: string;
+  last_status?: 'success' | 'failed';
+  last_error?: string;
+}
+
+export interface PlashboardState {
+  version: 1;
+  active_template_id: string | null;
+  template_runs: Record<string, TemplateRunState>;
+  display_profile?: DisplayProfile;
+}
+
+export interface RunArtifact {
+  template_id: string;
+  trigger: 'schedule' | 'manual';
+  status: 'success' | 'failed';
+  started_at: string;
+  finished_at: string;
+  duration_ms: number;
+  attempt_count: number;
+  published: boolean;
+  errors: string[];
+  response?: unknown;
+}
+
+export interface ToolResponse<T = Record<string, unknown>> {
+  ok: boolean;
+  errors: string[];
+  data?: T;
+}
+
+export interface FillResponse {
+  values: Record<string, unknown>;
+}
+
+export interface FillRunContext {
+  template: DashboardTemplate;
+  currentValues: Record<string, unknown>;
+  attempt: number;
+  errorHint?: string;
+}
+
+export interface FillRunner {
+  run(context: FillRunContext): Promise<FillResponse>;
+}
+
+export interface RuntimeStatus {
+  active_template_id: string | null;
+  template_count: number;
+  enabled_template_count: number;
+  running_template_ids: string[];
+  state: PlashboardState;
+}

package/src/utils.ts

@@ -0,0 +1,46 @@
+import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+export function nowIso(): string {
+  return new Date().toISOString();
+}
+
+export function deepClone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export async function ensureDir(path: string): Promise<void> {
+  await mkdir(path, { recursive: true });
+}
+
+export async function readJsonFile<T>(path: string): Promise<T | null> {
+  try {
+    const text = await readFile(path, 'utf8');
+    return JSON.parse(text) as T;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return null;
+    }
+    throw error;
+  }
+}
+
+export async function atomicWriteJson(path: string, value: unknown): Promise<void> {
+  const targetDir = dirname(path);
+  await ensureDir(targetDir);
+  const tmpBase = await mkdtemp(join(targetDir, '.plashboard-write-'));
+  const tmpPath = join(tmpBase, 'next.json');
+  await writeFile(tmpPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  await rename(tmpPath, path);
+  await rm(tmpBase, { recursive: true, force: true });
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function asErrorMessage(value: unknown): string {
+  if (value instanceof Error) return value.message;
+  if (typeof value === 'string') return value;
+  return JSON.stringify(value);
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "types": ["node", "vitest/globals"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['src/**/*.test.ts']
+  }
+});