thatcher 1.0.4

package/src/app/api/health/route.js

@@ -0,0 +1,95 @@
+import fs from 'fs'
+import path from 'path'
+import { getDatabase } from '@/engine'
+import { getAllMetrics } from '@/lib/metrics-collector.js'
+import { getDatabaseStats } from '@/lib/db-monitor.js'
+import { getCurrentResources } from '@/lib/resource-monitor.js'
+import { getRecentAlerts } from '@/lib/alert-manager.js'
+
+function getLastSyncAt() {
+  try {
+    const dir = path.resolve('data')
+    if (!fs.existsSync(dir)) return null
+    const files = fs.readdirSync(dir).map(f => path.join(dir, f)).filter(p => { try { return fs.statSync(p).isFile() } catch { return false } })
+    if (!files.length) return null
+    const mt = Math.max(...files.map(p => fs.statSync(p).mtimeMs))
+    return new Date(mt).toISOString()
+  } catch { return null }
+}
+
+export const GET = async (request) => {
+  try {
+    const db = getDatabase()
+    const start = process.hrtime.bigint()
+
+    db.prepare('SELECT 1').get()
+    db.pragma('wal_checkpoint(PASSIVE)')
+
+    const dbLatency = Number(process.hrtime.bigint() - start) / 1000000
+    const url = new URL(request.url)
+    const detailed = url.searchParams.get('detailed') === 'true'
+
+    const health = {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      uptime_ms: Math.round(process.uptime() * 1000),
+      last_sync_at: getLastSyncAt(),
+      database: {
+        connected: true,
+        latency: dbLatency
+      },
+      db: 'ok'
+    }
+
+    if (detailed) {
+      const { getUser, setCurrentRequest } = await import('@/engine.server')
+      setCurrentRequest(request)
+      const user = await getUser()
+      if (user && (user.role === 'admin' || user.role === 'partner')) {
+        health.metrics = getAllMetrics()
+        health.database.stats = getDatabaseStats()
+        health.resources = getCurrentResources()
+        health.alerts = getRecentAlerts(10)
+        health.memory = {
+          heapUsed: process.memoryUsage().heapUsed,
+          heapTotal: process.memoryUsage().heapTotal,
+          external: process.memoryUsage().external,
+          rss: process.memoryUsage().rss
+        }
+      }
+    }
+
+    return new Response(
+      JSON.stringify(health, null, 2),
+      {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' }
+      }
+    )
+  } catch (error) {
+    console.error('[Health] Check failed:', error)
+    return new Response(
+      JSON.stringify({
+        status: 'error',
+        error: error.message,
+        timestamp: new Date().toISOString()
+      }),
+      {
+        status: 503,
+        headers: { 'Content-Type': 'application/json' }
+      }
+    )
+  }
+}
+
+export const HEAD = async (request) => {
+  try {
+    const db = getDatabase()
+    db.prepare('SELECT 1').get()
+    return new Response(null, { status: 200 })
+  } catch (error) {
+    console.error('[Health] Check failed:', error)
+    return new Response(null, { status: 503 })
+  }
+}

package/src/app/api/metrics/route.js

@@ -0,0 +1,73 @@
+import { getAllMetrics, clearMetrics } from '@/lib/metrics-collector.js'
+import { getRecentAlerts } from '@/lib/alert-manager.js'
+import { getDatabaseStats } from '@/lib/db-monitor.js'
+import { getCurrentResources } from '@/lib/resource-monitor.js'
+import { getLogs } from '@/lib/log-aggregator.js'
+
+export const GET = async (request) => {
+  try {
+    const { requireUser, setCurrentRequest } = await import('@/engine.server')
+    setCurrentRequest(request)
+    const user = await requireUser()
+    if (user.role !== 'admin' && user.role !== 'partner') {
+      return new Response(JSON.stringify({ error: 'Permission denied' }), { status: 403, headers: { 'Content-Type': 'application/json' } })
+    }
+
+    const url = new URL(request.url)
+    const type = url.searchParams.get('type') || 'all'
+
+    let data = {}
+
+    if (type === 'all' || type === 'metrics') {
+      data.metrics = getAllMetrics()
+    }
+
+    if (type === 'all' || type === 'alerts') {
+      data.alerts = getRecentAlerts(50)
+    }
+
+    if (type === 'all' || type === 'database') {
+      data.database = getDatabaseStats()
+    }
+
+    if (type === 'all' || type === 'resources') {
+      data.resources = getCurrentResources()
+    }
+
+    if (type === 'all' || type === 'logs') {
+      const level = url.searchParams.get('level')
+      const since = url.searchParams.get('since')
+      const search = url.searchParams.get('search')
+      const limit = parseInt(url.searchParams.get('limit')) || 100
+
+      data.logs = getLogs({ level, since, search, limit })
+    }
+
+    return new Response(
+      JSON.stringify(data, null, 2),
+      {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' }
+      }
+    )
+  } catch (error) {
+    const status = error.statusCode || (error.code === 'UNAUTHORIZED' ? 401 : 500);
+    return new Response(JSON.stringify({ error: error.message }), { status, headers: { 'Content-Type': 'application/json' } });
+  }
+}
+
+export const DELETE = async (request) => {
+  try {
+    const { requireUser, setCurrentRequest } = await import('@/engine.server')
+    setCurrentRequest(request)
+    const user = await requireUser()
+    if (user.role !== 'admin') {
+      return new Response(JSON.stringify({ error: 'Permission denied' }), { status: 403, headers: { 'Content-Type': 'application/json' } })
+    }
+    clearMetrics()
+    return new Response(JSON.stringify({ success: true, message: 'Metrics cleared' }), { status: 200, headers: { 'Content-Type': 'application/json' } })
+  } catch (error) {
+    const status = error.statusCode || (error.code === 'UNAUTHORIZED' ? 401 : 500);
+    return new Response(JSON.stringify({ error: error.message }), { status, headers: { 'Content-Type': 'application/json' } });
+  }
+}

package/src/app/api/monitoring/dashboard/route.js

@@ -0,0 +1,18 @@
+import { renderMonitoringDashboard } from '@/ui/monitoring-dashboard.js'
+
+export const GET = async (request) => {
+  const { getUser, setCurrentRequest } = await import('@/engine.server')
+  setCurrentRequest(request)
+  const user = await getUser()
+  if (!user) {
+    return new Response(JSON.stringify({ error: 'Unauthorized' }), { status: 401, headers: { 'Content-Type': 'application/json' } })
+  }
+  if (user.role !== 'admin' && user.role !== 'partner') {
+    return new Response(JSON.stringify({ error: 'Permission denied' }), { status: 403, headers: { 'Content-Type': 'application/json' } })
+  }
+  const html = renderMonitoringDashboard()
+  return new Response(html, {
+    status: 200,
+    headers: { 'Content-Type': 'text/html; charset=utf-8' }
+  })
+}

package/src/cli.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env bun
+
+/**
+ * Thatcher CLI
+ * Usage:
+ *   thatcher start           - Start server with auto-discovered config
+ *   thatcher dev             - Start server with hot reload
+ *   thatcher console         - Open REPL with thatcher API
+ *   thatcher migrate         - Run database migrations only
+ *   thatcher validate        - Validate configuration
+ *   thatcher example         - Generate example config
+ */
+
+import { startThatcher, Thatcher } from './index.js';
+import { command } from 'commander'; // We'll use simple args parsing
+import * as readline from 'readline';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case 'start':
+    case 'dev':
+      console.log(`[Thatcher] Starting in ${command} mode...`);
+      const thatcher = new Thatcher({
+        server: { hotReload: command === 'dev' },
+      });
+      try {
+        await thatcher.init();
+        await thatcher.startServer();
+      } catch (err) {
+        console.error('[Thatcher] Failed to start:', err.message);
+        if (err.stack) console.error(err.stack);
+        process.exit(1);
+      }
+      break;
+
+    case 'migrate':
+      console.log('[Thatcher] Running migrations...');
+      const t1 = new Thatcher({});
+      await t1.init();
+      console.log('✓ Migrations complete');
+      break;
+
+    case 'validate':
+      console.log('[Thatcher] Validating configuration...');
+      try {
+        const t2 = new Thatcher({});
+        await t2.init();
+        console.log('✓ Configuration is valid');
+        console.log(`  Entities: ${t2.getAllEntities().length}`);
+        console.log(`  Workflows: ${Object.keys(t2.config?.workflows || {}).length}`);
+      } catch (err) {
+        console.error('✗ Configuration error:', err.message);
+        process.exit(1);
+      }
+      break;
+
+    case 'console':
+    case 'repl':
+      await startRepl();
+      break;
+
+    case 'example':
+      generateExampleConfig();
+      break;
+
+    case '--help':
+    case '-h':
+    case 'help':
+      printHelp();
+      break;
+
+    default:
+      if (!command) {
+        printHelp();
+      } else {
+        console.error(`[Thatcher] Unknown command: ${command}`);
+        console.log('Run `thatcher help` for usage.');
+        process.exit(1);
+      }
+  }
+}
+
+async function startRepl() {
+  console.log('[Thatcher] Starting REPL...');
+  console.log('Available: thatcher (instance), create, get, list, etc.\n');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: 'thatcher> ',
+  });
+
+  const thatcher = new Thatcher({});
+  await thatcher.init();
+
+  // Expose thatcher in REPL context
+  const context = {
+    thatcher,
+    create: async (entity, data, user) => thatcher.create(entity, data, user),
+    get: async (entity, id) => thatcher.get(entity, id),
+    list: async (entity, where) => thatcher.list(entity, where),
+    update: async (entity, id, data, user) => thatcher.update(entity, id, data, user),
+    remove: async (entity, id) => thatcher.delete(entity, id),
+    search: async (entity, q, where) => thatcher.search(entity, q, where),
+    transition: async (entityType, entityId, wf, toState, user, reason) =>
+      thatcher.transition(entityType, entityId, wf, toState, user, reason),
+    config: thatcher.config,
+    entities: thatcher.getAllEntities(),
+  };
+
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      rl.prompt();
+      return;
+    }
+
+    try {
+      // Simple evaluation - in production use a proper sandbox
+      const result = eval(trimmed);
+      if (result && typeof result.then === 'function') {
+        const resolved = await result;
+        console.log(JSON.stringify(resolved, null, 2));
+      } else if (result !== undefined) {
+        console.log(JSON.stringify(result, null, 2));
+      }
+    } catch (err) {
+      console.error('Error:', err.message);
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    console.log('\n[Thatcher] Goodbye');
+    process.exit(0);
+  });
+}
+
+function generateExampleConfig() {
+  const exampleDir = path.resolve(process.cwd(), 'thatcher-example');
+  fs.mkdirSync(exampleDir, { recursive: true });
+
+  const config = `# Thatcher Example Configuration
+# This is a minimal config to get you started
+# Copy moonlanding's master-config.yml for full features
+
+roles:
+  admin:
+    hierarchy: 0
+    label: Admin
+    permissions_scope: global
+  user:
+    hierarchy: 1
+    label: User
+    permissions_scope: assigned
+
+permission_templates:
+  basic:
+    admin:
+      - list
+      - view
+      - create
+      - edit
+      - delete
+    user:
+      - list
+      - view
+
+entities:
+  item:
+    label: Item
+    label_plural: Items
+    fields:
+      name:
+        type: text
+        required: true
+      description:
+        type: textarea
+      status:
+        type: enum
+        options: ['active', 'archived']
+        default: active
+
+workflows:
+  simple_workflow:
+    stages:
+      - draft
+      - active
+      - completed
+
+thresholds:
+  system:
+    pagination:
+      default_page_size: 20
+      max_page_size: 100
+`;
+
+  fs.writeFileSync(path.join(exampleDir, 'thatcher.config.yml'), config);
+  console.log(`✓ Example config written to ${exampleDir}/`);
+  console.log('  cd', exampleDir);
+  console.log('  thatcher start');
+}
+
+function printHelp() {
+  console.log(`
+ Thatcher CLI - Configuration-Driven Application Framework
+
+Usage:
+  thatcher <command>
+
+Commands:
+  start      Start the server (production mode)
+  dev        Start the server with hot reload
+  migrate    Run database migrations only
+  validate   Validate configuration file
+  console    Open interactive REPL
+  example    Generate example configuration
+  help       Show this help
+
+Configuration:
+  Place a thatcher.config.yml or master-config.yml in the current directory.
+  See the documentation for full configuration options.
+
+Environment Variables:
+  DATABASE_PATH   Path to SQLite database (default: ./data/app.db)
+  PORT            Server port (default: 3000)
+  NODE_ENV        Environment (development|production)
+
+Quick Start:
+  thatcher example    # Generate a starter config
+  thatcher start      # Launch the server
+`);
+}
+
+main().catch((err) => {
+  console.error('[Thatcher] Fatal error:', err);
+  process.exit(1);
+});

package/src/config/config-loader.js

@@ -0,0 +1,112 @@
+/**
+ * Configuration loading and management
+ * Adapted from moonlanding/src/config/
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Load configuration from YAML file or object
+ */
+export async function loadConfig(configSource) {
+  let config;
+
+  if (typeof configSource === 'string') {
+    // File path
+    const configPath = path.resolve(process.cwd(), configSource);
+    if (!fs.existsSync(configPath)) {
+      throw new Error(`Configuration file not found: ${configPath}`);
+    }
+    const content = fs.readFileSync(configPath, 'utf-8');
+    config = yaml.load(content);
+  } else if (typeof configSource === 'object') {
+    // Raw object
+    config = configSource;
+  } else {
+    throw new Error('Config must be a file path or object');
+  }
+
+  return config;
+}
+
+/**
+ * Validate required configuration sections
+ */
+export function validateConfig(config) {
+  const errors = [];
+
+  if (!config) {
+    errors.push('Configuration is empty');
+    return errors;
+  }
+
+  // Check required sections
+  const requiredSections = ['entities', 'roles', 'permission_templates'];
+  for (const section of requiredSections) {
+    if (!config[section]) {
+      errors.push(`Missing required section: ${section}`);
+    }
+  }
+
+  // Validate roles
+  if (config.roles) {
+    const roleNames = Object.keys(config.roles);
+    if (roleNames.length === 0) {
+      errors.push('At least one role must be defined');
+    }
+  }
+
+  // Validate entities
+  if (config.entities) {
+    for (const [entityName, entityDef] of Object.entries(config.entities)) {
+      if (!entityDef.fields && !entityDef.children) {
+        errors.push(`Entity '${entityName}' must have fields or children defined`);
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Get configuration with defaults applied
+ */
+export function getConfigWithDefaults(userConfig) {
+  const defaults = {
+    system: {
+      pagination: { default_page_size: 50, max_page_size: 500 },
+      limits: { max_upload_size: 10485760, max_query_results: 10000 },
+    },
+    thresholds: {
+      timing: { lockout_seconds: 300 },
+      ui: { skeleton_count: 3 },
+      polling: { chat_ms: 3000, staleness_days: 8 },
+    },
+    features: {},
+    notifications: {},
+    automation: { schedules: [] },
+    domains: {},
+    highlights: { palette: [] },
+    icons: {},
+    theme: {},
+  };
+
+  return deepMerge(defaults, userConfig);
+}
+
+/**
+ * Deep merge utility
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = deepMerge(target[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}

package/src/config/constants.js

@@ -0,0 +1,127 @@
+/**
+ * Core constants for Thatcher SDK
+ * HTTP codes, status values, display limits, etc.
+ */
+
+/**
+ * HTTP status codes
+ */
+export const HTTP = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_ERROR: 500,
+  SERVICE_UNAVAILABLE: 503,
+};
+
+/**
+ * Error message templates
+ */
+export const ERROR_MESSAGES = {
+  notFound: (entity = 'Resource') => `${entity} not found`,
+  invalidRequest: (reason = 'Invalid request') => reason,
+  operationFailed: (operation = 'Operation') => `${operation} failed`,
+  permission: {
+    denied: 'Permission denied',
+  },
+};
+
+/**
+ * Success message templates
+ */
+export const SUCCESS_MESSAGES = {
+  created: (entity = 'Item') => `${entity} created successfully`,
+  updated: (entity = 'Item') => `${entity} updated successfully`,
+  deleted: (entity = 'Item') => `${entity} deleted successfully`,
+  saved: 'Changes saved successfully',
+};
+
+/**
+ * Record status constants
+ */
+export const RECORD_STATUS = {
+  ACTIVE: 'active',
+  DELETED: 'deleted',
+  ARCHIVED: 'archived',
+};
+
+/**
+ * Email status
+ */
+export const EMAIL_STATUS = 'pending';
+
+/**
+ * Display/UI constants
+ */
+export const DISPLAY = {
+  MAX_API_CALLS_HISTORY: 100,
+  API_TIMEOUT_MS: 30000,
+  POLLING_INTERVAL_MS: 2000,
+  MAX_INLINE_ITEMS: 5,
+  MAX_UPLOAD_SIZE_MB: 100,
+  MAX_FILE_NAME_LENGTH: 255,
+  MAX_FIELD_NAME_LENGTH: 100,
+  TOAST_DURATION_MS: 3000,
+  MAX_NOTIFICATIONS: 50,
+  DEBOUNCE_SEARCH_MS: 300,
+  DEBOUNCE_FORM_CHANGE_MS: 500,
+};
+
+/**
+ * Validation patterns
+ */
+export const VALIDATION = {
+  EMAIL_REGEX: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  PASSWORD_MIN_LENGTH: 8,
+};
+
+/**
+ * Log prefixes for structured logging
+ */
+export const LOG_PREFIXES = {
+  API: '[API]',
+  DB: '[DB]',
+  AUTH: '[AUTH]',
+  CONFIG: '[Config]',
+  SERVICE: '[Service]',
+  system: '[System]',
+  email: '[Email]',
+  validation: '[Validation]',
+  database: '[DB]',
+};
+
+/**
+ * SQL type mapping
+ */
+export const SQL_TYPES = {
+  id: 'TEXT PRIMARY KEY',
+  text: 'TEXT',
+  textarea: 'TEXT',
+  email: 'TEXT',
+  int: 'INTEGER',
+  decimal: 'REAL',
+  bool: 'INTEGER',
+  date: 'INTEGER',
+  timestamp: 'INTEGER',
+  json: 'TEXT',
+  image: 'TEXT',
+  ref: 'TEXT',
+  enum: 'TEXT',
+};
+
+/**
+ * Authentication scopes (Google, etc.)
+ */
+export const AUTH_SCOPES = {
+  google: [
+    'https://www.googleapis.com/auth/userinfo.email',
+    'https://www.googleapis.com/auth/userinfo.profile',
+  ],
+};