@mmapp/react-compiler 0.1.0-alpha.1

package/seed-blueprint-glass-console.mjs

@@ -0,0 +1,445 @@
+/**
+ * Blueprint Glass Console — Compile + Seed Pipeline
+ *
+ * Compiles React views to JSON, composes the view tree, and seeds
+ * the database with both the view tree and the blueprint manifest.
+ *
+ * Modes:
+ *   node seed-blueprint-glass-console.mjs              → full (compile + seed)
+ *   node seed-blueprint-glass-console.mjs --seed-only  → seed only (skip compile)
+ *   node seed-blueprint-glass-console.mjs --compile-only → compile only (skip seed)
+ *   node seed-blueprint-glass-console.mjs --watch      → watch mode (auto-recompile + reseed)
+ *   node seed-blueprint-glass-console.mjs --silent     → suppress non-error output
+ */
+import { readFileSync, readdirSync, watchFile, unwatchFile, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ---------------------------------------------------------------------------
+// CLI argument parsing
+// ---------------------------------------------------------------------------
+const args = process.argv.slice(2);
+const SEED_ONLY = args.includes('--seed-only');
+const COMPILE_ONLY = args.includes('--compile-only');
+const WATCH = args.includes('--watch');
+const SILENT = args.includes('--silent');
+
+function log(...msg) {
+  if (!SILENT) console.log(...msg);
+}
+
+const compiledDir = join(__dirname, '../frontend/src/workflows/compiled/blueprint-glass-console');
+const sourceDir = join(__dirname, '../blueprint-glass-console/app');
+const API = 'http://178.156.197.133:3010/api/v1';
+
+// ---------------------------------------------------------------------------
+// Blueprint Manifest — single source of truth
+// ---------------------------------------------------------------------------
+const BLUEPRINT_MANIFEST = {
+  workflows: [{ slug: 'mm-glass-console', role: 'primary' }],
+  experience_id: 'mm-glass-console',
+  routes: [
+    {
+      path: '/mm-glass-console',
+      node: 'mm-glass-console',
+      label: 'Glass Console',
+      entityType: 'mm-glass-console',
+      entityIdSource: 'user',
+    },
+  ],
+  config: {
+    full_bleed: true,
+    default_mode: 'read',
+    auth_required: true,
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Compiled view loading
+// ---------------------------------------------------------------------------
+function loadCompiledView(slug) {
+  const data = JSON.parse(readFileSync(join(compiledDir, `${slug}.json`), 'utf-8'));
+  return data.ir.views?.default || data.ir.metadata?.experience;
+}
+
+function loadCompiledMeta(slug) {
+  const data = JSON.parse(readFileSync(join(compiledDir, `${slug}.json`), 'utf-8'));
+  return data.ir.metadata || {};
+}
+
+// ---------------------------------------------------------------------------
+// Slot → Component mapping
+// ---------------------------------------------------------------------------
+const SLOT_TO_COMPONENT = {
+  artifact: 'GcArtifactViewer',
+  timeline: 'GcRunTimeline',
+};
+
+// ---------------------------------------------------------------------------
+// Tree composition
+// ---------------------------------------------------------------------------
+function composeTree(node, childrenComponent) {
+  if (!node) return node;
+
+  // Replace Slot nodes with component references
+  if (node.component === 'Slot' && node.config?.name) {
+    const componentId = SLOT_TO_COMPONENT[node.config.name];
+    if (componentId) {
+      const replacement = {
+        id: `composed-${node.config.name}`,
+        component: componentId,
+      };
+      if (node.bindings?.props) {
+        const propBindings = parseSlotProps(node.bindings.props);
+        if (Object.keys(propBindings).length > 0) {
+          replacement.bindings = propBindings;
+        }
+      }
+      return replacement;
+    }
+  }
+
+  // Replace $instance.children with the appropriate page component
+  if (node.component === 'Text' && node.bindings?.value === '$instance.children') {
+    if (childrenComponent) {
+      return { id: 'composed-children', component: childrenComponent, config: { flex: 1, overflow: 'hidden' } };
+    }
+  }
+
+  if (node.children) {
+    node.children = node.children.map((child) => composeTree(child, childrenComponent));
+  }
+
+  return node;
+}
+
+// ---------------------------------------------------------------------------
+// Slot props parser
+// ---------------------------------------------------------------------------
+function parseSlotProps(propsStr) {
+  const bindings = {};
+  let inner = propsStr.trim();
+  if (inner.startsWith('{') && inner.endsWith('}')) {
+    inner = inner.slice(1, -1).trim();
+  }
+
+  let key = '';
+  let value = '';
+  let inValue = false;
+  let depth = 0;
+  let inString = false;
+  let stringChar = '';
+
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+
+    if (inString) {
+      value += ch;
+      if (ch === stringChar && inner[i - 1] !== '\\') inString = false;
+      continue;
+    }
+
+    if (ch === '"' || ch === "'" || ch === '`') {
+      inString = true;
+      stringChar = ch;
+      if (inValue) value += ch;
+      else key += ch;
+      continue;
+    }
+
+    if (ch === '(' || ch === '{' || ch === '[') depth++;
+    if (ch === ')' || ch === '}' || ch === ']') depth--;
+
+    if (!inValue && ch === ':' && depth === 0) {
+      inValue = true;
+      continue;
+    }
+
+    if (inValue && ch === ',' && depth === 0) {
+      const k = key.trim();
+      const v = value.trim();
+      if (k && v) bindings[k] = v;
+      key = '';
+      value = '';
+      inValue = false;
+      continue;
+    }
+
+    if (inValue) value += ch;
+    else key += ch;
+  }
+
+  const k = key.trim();
+  const v = value.trim();
+  if (k && v) bindings[k] = v;
+
+  return bindings;
+}
+
+// ---------------------------------------------------------------------------
+// Compile step — runs the Babel compiler
+// ---------------------------------------------------------------------------
+function runCompile() {
+  log('\n--- Compiling blueprint-glass-console views ---');
+  try {
+    execSync('node compile-blueprint-glass-console.mjs', {
+      cwd: __dirname,
+      stdio: SILENT ? 'pipe' : 'inherit',
+    });
+    log('Compile complete.\n');
+    return true;
+  } catch (err) {
+    console.error('Compile failed:', err.message);
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Seed step — compose tree + PATCH to DB (view + manifest)
+// ---------------------------------------------------------------------------
+async function runSeed() {
+  log('\n--- Seeding blueprint-glass-console to DB ---');
+
+  // Login
+  const loginRes = await fetch(API + '/auth/login', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email: 'admin@mindmatrix.com', password: 'Admin123!' }),
+  });
+  const { token } = await loginRes.json();
+  log('Logged in');
+
+  // Load all compiled views
+  const files = readdirSync(compiledDir).filter((f) => f.endsWith('.json'));
+  log(`Found ${files.length} compiled views`);
+
+  const views = {};
+  const metas = {};
+  for (const f of files) {
+    const slug = f.replace('.json', '');
+    views[slug] = loadCompiledView(slug);
+    metas[slug] = loadCompiledMeta(slug);
+  }
+
+  // Compose root tree
+  const rootView = JSON.parse(JSON.stringify(views['gc-layout']));
+  if (!rootView) {
+    console.error('gc-layout view tree not found!');
+    return false;
+  }
+
+  const rootDs = metas['gc-layout'].dataSources || [];
+  if (rootDs.length > 0) rootView.dataSources = rootDs;
+
+  const composedRoot = composeTree(rootView, 'GcPage');
+
+  // Log tree structure
+  let slotCount = 0;
+  let childrenCount = 0;
+  function countReplacements(node) {
+    if (node.id?.startsWith('composed-')) {
+      if (node.id === 'composed-children') childrenCount++;
+      else slotCount++;
+    }
+    (node.children || []).forEach(countReplacements);
+  }
+  countReplacements(composedRoot);
+  log(`  Replaced ${slotCount} slots, ${childrenCount} children placeholders`);
+
+  if (!SILENT) {
+    function logTree(node, depth = 0) {
+      const ds = node.dataSources?.length || 0;
+      const bind = Object.keys(node.bindings || {}).length;
+      const extra = [];
+      if (ds > 0) extra.push(`ds=${ds}`);
+      if (bind > 0) extra.push(`bind=${bind}`);
+      if (node.config?.localDefaults) extra.push('localDefaults');
+      const suffix = extra.length > 0 ? ` [${extra.join(', ')}]` : '';
+      console.log(`${'  '.repeat(depth)}${node.component} (${node.id})${suffix}`);
+      (node.children || []).forEach((c) => logTree(c, depth + 1));
+    }
+    console.log('\nComposed tree:');
+    logTree(composedRoot);
+  }
+
+  log(`\nTree size: ${JSON.stringify(composedRoot).length} bytes`);
+
+  // Get or create mm-glass-console definition
+  let def;
+  const defRes = await fetch(API + '/definitions/mm-glass-console', {
+    headers: { Authorization: 'Bearer ' + token },
+  });
+
+  if (defRes.ok) {
+    def = await defRes.json();
+    log(`Definition ID: ${def.id}`);
+  } else {
+    // Create the definition if it doesn't exist
+    log('Definition not found — creating...');
+    const createRes = await fetch(API + '/definitions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer ' + token,
+      },
+      body: JSON.stringify({
+        slug: 'mm-glass-console',
+        name: 'Glass Console',
+        description: 'Intent-driven data agent — calm interface for living reports',
+        category: ['blueprint', 'glass-console'],
+        version: '1.0.0',
+        view: composedRoot,
+        metadata: { blueprint_manifest: BLUEPRINT_MANIFEST },
+      }),
+    });
+
+    if (!createRes.ok) {
+      console.error('Create failed:', createRes.status, await createRes.text());
+      return false;
+    }
+
+    def = await createRes.json();
+    log(`Created definition: ${def.id}`);
+  }
+
+  // Merge manifest into existing metadata
+  const existingMetadata = def.metadata || {};
+  const updatedMetadata = {
+    ...existingMetadata,
+    blueprint_manifest: BLUEPRINT_MANIFEST,
+  };
+
+  // PATCH with BOTH view tree AND manifest metadata
+  const patchRes = await fetch(API + '/definitions/' + def.id, {
+    method: 'PATCH',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: 'Bearer ' + token,
+    },
+    body: JSON.stringify({
+      view: composedRoot,
+      metadata: updatedMetadata,
+    }),
+  });
+
+  if (!patchRes.ok) {
+    console.error('PATCH failed:', patchRes.status, await patchRes.text());
+    return false;
+  }
+  log('View tree + manifest updated');
+
+  // Verify
+  const verifyRes = await fetch(API + '/definitions/mm-glass-console', {
+    headers: { Authorization: 'Bearer ' + token },
+  });
+  const verified = await verifyRes.json();
+  const hasManifest = !!verified.metadata?.blueprint_manifest;
+  const hasFullBleed = verified.metadata?.blueprint_manifest?.config?.full_bleed === true;
+  const hasRoutes = verified.metadata?.blueprint_manifest?.routes?.length > 0;
+  log(`\nVerified:`);
+  log(`  view: ${JSON.stringify(verified.view).length} bytes, root=${verified.view?.component}`);
+  log(`  manifest: ${hasManifest ? 'present' : 'MISSING'}`);
+  log(`  full_bleed: ${hasFullBleed}`);
+  log(`  routes: ${hasRoutes ? verified.metadata.blueprint_manifest.routes.length : 0}`);
+
+  if (!hasManifest || !hasFullBleed) {
+    console.error('Manifest verification failed!');
+    return false;
+  }
+
+  log('\nSeed complete.');
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Watch mode
+// ---------------------------------------------------------------------------
+function startWatch() {
+  log('\n--- Watch mode: monitoring blueprint-glass-console sources ---');
+  log(`  Source: ${sourceDir}`);
+  log(`  Compiled: ${compiledDir}`);
+  log('  Press Ctrl+C to stop.\n');
+
+  function findFiles(dir) {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) files.push(...findFiles(full));
+      else if (entry.name.endsWith('.tsx')) files.push(full);
+    }
+    return files;
+  }
+
+  const sourceFiles = existsSync(sourceDir) ? findFiles(sourceDir) : [];
+  log(`Watching ${sourceFiles.length} source files...`);
+
+  let debounceTimer = null;
+  let isRunning = false;
+
+  async function onChange(filename) {
+    if (isRunning) return;
+    if (debounceTimer) clearTimeout(debounceTimer);
+
+    debounceTimer = setTimeout(async () => {
+      isRunning = true;
+      const ts = new Date().toLocaleTimeString();
+      log(`\n[${ts}] Change detected: ${filename}`);
+
+      const compiled = runCompile();
+      if (compiled) {
+        await runSeed();
+      }
+
+      isRunning = false;
+      log(`\n[${new Date().toLocaleTimeString()}] Waiting for changes...`);
+    }, 500);
+  }
+
+  for (const file of sourceFiles) {
+    watchFile(file, { interval: 1000 }, () => onChange(file));
+  }
+
+  process.on('SIGINT', () => {
+    log('\nStopping watch...');
+    for (const file of sourceFiles) unwatchFile(file);
+    process.exit(0);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+  log('Blueprint Glass Console Pipeline');
+  log(`  Mode: ${WATCH ? 'watch' : COMPILE_ONLY ? 'compile-only' : SEED_ONLY ? 'seed-only' : 'full'}`);
+
+  if (WATCH) {
+    const compiled = runCompile();
+    if (compiled) await runSeed();
+    startWatch();
+    return;
+  }
+
+  if (COMPILE_ONLY) {
+    runCompile();
+    return;
+  }
+
+  if (SEED_ONLY) {
+    await runSeed();
+    return;
+  }
+
+  // Full mode: compile + seed
+  const compiled = runCompile();
+  if (compiled) {
+    await runSeed();
+  }
+}
+
+main().catch((e) => console.error(e));