aub-workspace 0.3.0

package/vendor/aub/scripts/sync-brand-assets.mjs

@@ -0,0 +1,33 @@
+import { copyFile, mkdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const root = resolve(import.meta.dirname, '..');
+const source = resolve(root, 'brand');
+const targets = [
+  resolve(root, 'site/assets/brand'),
+  resolve(root, 'apps/editor/public/brand'),
+];
+const files = [
+  'aub-logo-mark.svg',
+  'favicon.svg',
+  'favicon-16x16.png',
+  'favicon-32x32.png',
+  'favicon-48x48.png',
+  'favicon.ico',
+  'apple-touch-icon.png',
+  'app-icon-192.png',
+  'app-icon-512.png',
+  'app-icon-1024.png',
+  'android-chrome-192x192.png',
+  'android-chrome-512x512.png',
+  'mstile-150x150.png',
+  'safari-pinned-tab.svg',
+  'maskable-icon-512.png',
+];
+
+for (const target of targets) {
+  await mkdir(target, { recursive: true });
+  await Promise.all(files.map((file) => copyFile(resolve(source, file), resolve(target, file))));
+}
+
+console.log(`Synced ${files.length} brand assets to ${targets.length} deploy targets.`);

package/vendor/aub/scripts/validate-blueprint.lib.d.mts

@@ -0,0 +1,14 @@
+export type Blueprint = Record<string, any>;
+
+export interface KnownTypeMeta {
+  isContainer: boolean;
+  source?: string;
+}
+
+export type KnownTypes = Map<string, KnownTypeMeta>;
+
+export function validateBlueprintSemantics(
+  blueprint: Blueprint,
+  options?: { knownTypes?: KnownTypes }
+): string[];
+export function resolvePlacement(node: Record<string, any>, viewportId: string): Record<string, any> | null;

package/vendor/aub/scripts/validate-blueprint.lib.mjs

@@ -0,0 +1,136 @@
+export function validateBlueprintSemantics(blueprint, { knownTypes } = {}) {
+  const errors = [];
+  const nodes = Array.isArray(blueprint?.nodes) ? blueprint.nodes : [];
+  const byId = new Map();
+  const interactionSources = new Set();
+
+  for (const node of nodes) {
+    if (byId.has(node.id)) errors.push(`duplicate node id: ${node.id}`);
+    byId.set(node.id, node);
+    interactionSources.add(node.id);
+    for (const item of node.content?.items ?? []) {
+      if (item?.id) interactionSources.add(item.id);
+    }
+  }
+
+  if (knownTypes) {
+    for (const node of nodes) {
+      const type = node?.type;
+      if (typeof type !== 'string') continue;
+      const isExtension = type.includes(':');
+      const meta = knownTypes.get(type);
+      if (!meta) {
+        if (isExtension) {
+          errors.push(
+            `${node.id}: unknown component type "${type}" — declare it in aub.registry.json`
+          );
+        }
+        // Core-looking unknown types are already rejected by the JSON Schema enum.
+        continue;
+      }
+      if (isExtension && !meta.isContainer && (node.children ?? []).length > 0) {
+        errors.push(
+          `${node.id}: extension type "${type}" is a leaf (isContainer:false) but declares children`
+        );
+      }
+    }
+  }
+
+  const roots = nodes.filter((node) => node.parent_id == null);
+  if (roots.length !== 1) errors.push(`expected exactly one root node, found ${roots.length}`);
+
+  for (const node of nodes) {
+    if (node.parent_id != null && !byId.has(node.parent_id)) {
+      errors.push(`${node.id}: parent_id references missing node ${node.parent_id}`);
+    } else if (node.parent_id != null) {
+      const parent = byId.get(node.parent_id);
+      if (!(parent.children ?? []).includes(node.id)) {
+        errors.push(`${node.id}: parent ${node.parent_id} does not declare it in children`);
+      }
+    }
+    for (const childId of node.children ?? []) {
+      const child = byId.get(childId);
+      if (!child) {
+        errors.push(`${node.id}: children references missing node ${childId}`);
+      } else if (child.parent_id !== node.id) {
+        errors.push(`${node.id}: child ${childId} has parent_id ${String(child.parent_id)}`);
+      }
+    }
+    for (const stateKey of ['empty_state', 'loading_state', 'error_state']) {
+      const stateId = node.content?.[stateKey];
+      if (stateId && !byId.has(stateId)) {
+        errors.push(`${node.id}: content.${stateKey} references missing node ${stateId}`);
+      }
+    }
+    if (node.layout?.mode === 'freeform') {
+      const children = (node.children ?? []).map((id) => byId.get(id)).filter(Boolean);
+      const viewports = blueprint.viewports ?? [];
+      for (const child of children) {
+        for (const viewport of viewports) {
+          const placement = child.placements?.[viewport.id];
+          if (!placement) {
+            errors.push(`${child.id}: missing placement for ${viewport.id} inside freeform parent ${node.id}`);
+            continue;
+          }
+          if (placement.x < 0 || placement.y < 0) {
+            errors.push(`${child.id}: placement for ${viewport.id} has negative coordinates`);
+          }
+          if (placement.width <= 0 || placement.height <= 0) {
+            errors.push(`${child.id}: placement for ${viewport.id} must have positive size`);
+          }
+          if (placement.x + placement.width > viewport.width) {
+            errors.push(`${child.id}: placement for ${viewport.id} overflows viewport width ${viewport.width}`);
+          }
+        }
+      }
+    }
+  }
+
+  if (roots.length === 1) {
+    const visited = new Set();
+    const active = new Set();
+    const walk = (id) => {
+      if (active.has(id)) {
+        errors.push(`component tree contains a cycle at ${id}`);
+        return;
+      }
+      if (visited.has(id)) return;
+      visited.add(id);
+      active.add(id);
+      const node = byId.get(id);
+      for (const childId of node?.children ?? []) {
+        if (byId.has(childId)) walk(childId);
+      }
+      active.delete(id);
+    };
+    walk(roots[0].id);
+    for (const node of nodes) {
+      if (!visited.has(node.id)) errors.push(`${node.id}: node is not reachable from root ${roots[0].id}`);
+    }
+  }
+
+  for (const interaction of blueprint?.interactions ?? []) {
+    if (!interactionSources.has(interaction.source_node_id)) {
+      errors.push(`${interaction.id}: source_node_id references missing node ${interaction.source_node_id}`);
+    }
+  }
+
+  for (const responsive of blueprint?.responsive ?? []) {
+    if (!byId.has(responsive.target_node_id)) {
+      errors.push(`responsive ${responsive.viewport}/${responsive.rule}: missing target ${responsive.target_node_id}`);
+    }
+  }
+
+  return errors;
+}
+
+export function resolvePlacement(node, viewportId) {
+  const placements = node?.placements;
+  if (!placements) return null;
+  return placements[viewportId]
+    ?? placements.desktop
+    ?? placements.tablet
+    ?? placements.mobile
+    ?? placements.wide
+    ?? null;
+}

package/vendor/aub/scripts/validate.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// Validates a UI Blueprint file against the JSON Schema.
+// Usage: node scripts/validate.mjs <file.ui.json|file.ui.yaml>
+
+import { readFile } from 'node:fs/promises';
+import { resolve, extname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import yaml from 'js-yaml';
+import { validateBlueprintSemantics } from './validate-blueprint.lib.mjs';
+import { buildKnownTypes } from './registry.lib.mjs';
+import { validateProjectFile } from './project.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+
+function parseArgs(argv) {
+  const args = { file: null, registry: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--registry') {
+      args.registry = argv[i + 1];
+      i += 1;
+    } else if (token.startsWith('--registry=')) {
+      args.registry = token.slice('--registry='.length);
+    } else if (!args.file) {
+      args.file = token;
+    }
+  }
+  return args;
+}
+
+async function main() {
+  const { file: arg, registry: registryArg } = parseArgs(process.argv.slice(2));
+  if (!arg) {
+    console.error('Usage: pnpm validate <file.ui.json|file.ui.yaml> [--registry <aub.registry.json>]');
+    process.exit(2);
+  }
+  const filePath = resolve(arg);
+  const ext = extname(filePath).toLowerCase();
+
+  const schemaPath = join(ROOT, 'schema', 'ui-blueprint.schema.json');
+  const schemaRaw = await readFile(schemaPath, 'utf8');
+  const schema = JSON.parse(schemaRaw);
+
+  const ajv = new Ajv2020({ allErrors: true, strict: true });
+  addFormats(ajv);
+  const validate = ajv.compile(schema);
+
+  const fileRaw = await readFile(filePath, 'utf8');
+  let document;
+  if (ext === '.yaml' || ext === '.yml') {
+    document = yaml.load(fileRaw);
+  } else {
+    document = JSON.parse(fileRaw);
+  }
+
+  const looksLikeProject =
+    /\.aub\.project\.json$/i.test(filePath) ||
+    (document &&
+      typeof document === 'object' &&
+      Array.isArray(document.screens) &&
+      document.entry_screen != null &&
+      !('nodes' in document));
+  if (looksLikeProject) {
+    console.log('→ detected project document; validating as project');
+    const result = await validateProjectFile(filePath);
+    if (result.perScreen) {
+      for (const screen of result.perScreen) {
+        if (screen.ok) {
+          console.log(`  ✓ screen ${screen.id}`);
+        } else {
+          console.error(`  ✗ screen ${screen.id}`);
+        }
+      }
+    }
+    if (result.ok) {
+      console.log(`✓ valid project: ${arg}`);
+      process.exit(0);
+    }
+    console.error(`✗ invalid project: ${arg}`);
+    for (const error of result.errors) {
+      console.error(`  ${error}`);
+    }
+    process.exit(1);
+  }
+
+  let knownTypes;
+  let extensionPath = null;
+  try {
+    const resolved = await buildKnownTypes({
+      extensionPath: registryArg ? resolve(registryArg) : null,
+      startDir: dirname(filePath),
+    });
+    knownTypes = resolved.knownTypes;
+    extensionPath = resolved.extensionPath;
+  } catch (err) {
+    console.error(`✗ invalid: ${arg}`);
+    console.error(`  registry: ${err.message}`);
+    process.exit(1);
+  }
+
+  const ok = validate(document);
+  const semanticErrors = ok ? validateBlueprintSemantics(document, { knownTypes }) : [];
+  if (ok && semanticErrors.length === 0) {
+    const suffix = extensionPath ? ` (extensions: ${extensionPath})` : '';
+    console.log(`✓ valid: ${arg}${suffix}`);
+    process.exit(0);
+  }
+
+  console.error(`✗ invalid: ${arg}`);
+  for (const err of validate.errors ?? []) {
+    const path = err.instancePath || '(root)';
+    console.error(`  ${path} ${err.message}`);
+    if (err.params) console.error(`    params: ${JSON.stringify(err.params)}`);
+  }
+  for (const error of semanticErrors) {
+    console.error(`  semantic: ${error}`);
+  }
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(2);
+});

package/vendor/aub/scripts/verify-implementation-report.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import Ajv2020 from 'ajv/dist/2020.js';
+import { readFile } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import yaml from 'js-yaml';
+import reportSchema from '../schema/implementation-report.schema.json' with { type: 'json' };
+import { verifyImplementationReport } from './implementation-report.lib.mjs';
+
+const [blueprintPath, reportPath] = process.argv.slice(2);
+if (!blueprintPath || !reportPath) {
+  console.error('Usage: node scripts/verify-implementation-report.mjs <blueprint.ui.json|yaml> <report.json>');
+  process.exit(2);
+}
+
+const [blueprint, report] = await Promise.all([
+  readBlueprint(blueprintPath),
+  readFile(resolve(reportPath), 'utf8').then(JSON.parse),
+]);
+const validate = new Ajv2020({ allErrors: true, strict: false }).compile(reportSchema);
+if (!validate(report)) {
+  for (const error of validate.errors ?? []) {
+    console.error(`✗ ${error.instancePath || '(root)'} ${error.message}`);
+  }
+  process.exit(1);
+}
+
+const result = verifyImplementationReport(blueprint, report);
+console.log(JSON.stringify(result, null, 2));
+process.exit(result.ready ? 0 : 1);
+
+async function readBlueprint(path) {
+  const text = await readFile(resolve(path), 'utf8');
+  const extension = extname(path).toLowerCase();
+  return extension === '.yaml' || extension === '.yml' ? yaml.load(text) : JSON.parse(text);
+}

package/vendor/aub/scripts/workspace-loop.lib.d.mts

@@ -0,0 +1,17 @@
+export const WORKSPACE_LOOP_VERSION: string;
+export const AUB_DIR: string;
+export const SESSION_PATH: string;
+export const COMPONENT_CANDIDATES_PATH: string;
+export const TEMPLATE_DIR: string;
+export const TEMPLATE_FORMAT: string;
+export const TEMPLATE_FORMAT_VERSION: string;
+
+export function readAubSession(root: string): Promise<Record<string, any>>;
+export function updateAubSession(root: string, patch?: Record<string, any>): Promise<{ path: string; session: Record<string, any> }>;
+export function readComponentCandidates(root: string): Promise<{ format: string; format_version: string; candidates: any[] }>;
+export function listWorkspaceTemplates(root: string): Promise<any[]>;
+export function getWorkspaceStatus(root: string): Promise<Record<string, any>>;
+export function scanProjectUi(root: string, options?: Record<string, any>): Promise<Record<string, any>>;
+export function generateTemplateFromSource(root: string, args?: Record<string, any>): Promise<{ savedPath: string; template: Record<string, any> }>;
+export function approveComponentCandidate(root: string, args?: Record<string, any>): Promise<Record<string, any>>;
+export function templateAuthoringPrompt(): string;