aiox-core 5.0.2 → 5.0.3

package/pro/squads/design/scripts/design-system/design_manifest_lib.cjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+function readYaml(filePath) {
+  return yaml.load(fs.readFileSync(filePath, 'utf8')) || {};
+}
+
+function writeYaml(filePath, data) {
+  const text = yaml.dump(data, {
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+  fs.writeFileSync(filePath, text, 'utf8');
+}
+
+function normalizeDescription(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+
+  return value
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .slice(0, 2)
+    .join(' ');
+}
+
+function buildTierSystem(squad, currentConfig) {
+  const source = squad.tier_system || {};
+  const fallback = (currentConfig && currentConfig.tier_system) || {};
+
+  return {
+    tier_0_foundation: {
+      description:
+        (source.tier_0_foundation && source.tier_0_foundation.purpose) ||
+        (fallback.tier_0_foundation && fallback.tier_0_foundation.description) ||
+        'Entry point agents for diagnosis and strategy',
+      agents: (source.tier_0_foundation && source.tier_0_foundation.agents) || []
+    },
+    tier_1_masters: {
+      description:
+        (source.tier_1_masters && source.tier_1_masters.purpose) ||
+        (fallback.tier_1_masters && fallback.tier_1_masters.description) ||
+        'Execution masters with specialized expertise',
+      agents: (source.tier_1_masters && source.tier_1_masters.agents) || []
+    },
+    tier_2_specialists: {
+      description:
+        (source.tier_2_specialists && source.tier_2_specialists.purpose) ||
+        (fallback.tier_2_specialists && fallback.tier_2_specialists.description) ||
+        'Deep specialists for specific deliverables',
+      agents: (source.tier_2_specialists && source.tier_2_specialists.agents) || []
+    },
+    orchestrator: {
+      description:
+        (fallback.orchestrator && fallback.orchestrator.description) || 'Routes requests to appropriate agents',
+      agent:
+        (currentConfig && currentConfig.entry_agent) ||
+        (squad.config && squad.config.default_agent) ||
+        'design-chief'
+    }
+  };
+}
+
+function buildGeneratedConfig(squad, currentConfig) {
+  const metadata = squad.metadata || {};
+
+  return {
+    ...currentConfig,
+    name: metadata.name || currentConfig.name,
+    version: metadata.version || currentConfig.version,
+    title: metadata.display_name || currentConfig.title,
+    description: normalizeDescription(squad.description) || currentConfig.description,
+    entry_agent:
+      currentConfig.entry_agent ||
+      (squad.config && squad.config.default_agent) ||
+      'design-chief',
+    tier_system: buildTierSystem(squad, currentConfig),
+    agents: (squad.agents || []).map((agent) => agent.id),
+    tasks: (squad.tasks || []).map((task) => task.id),
+    templates: (squad.templates || []).map((template) => template.id),
+    checklists: (squad.checklists || []).map((checklist) => checklist.id),
+    workflows: (squad.workflows || []).map((workflow) => workflow.id),
+    tags: squad.tags || currentConfig.tags || []
+  };
+}
+
+function getCanonicalProjection(config) {
+  return {
+    name: config.name,
+    version: config.version,
+    entry_agent: config.entry_agent,
+    tier_system: config.tier_system,
+    agents: config.agents,
+    tasks: config.tasks,
+    templates: config.templates,
+    checklists: config.checklists,
+    workflows: config.workflows,
+    tags: config.tags
+  };
+}
+
+function sortObjectDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortObjectDeep);
+  }
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value).sort();
+    const sorted = {};
+    for (const key of keys) {
+      sorted[key] = sortObjectDeep(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+
+function stableJson(value) {
+  return JSON.stringify(sortObjectDeep(value), null, 2);
+}
+
+function getDesignPaths(rootDir) {
+  const base = path.join(rootDir, 'squads/design');
+  return {
+    squadPath: path.join(base, 'squad.yaml'),
+    configPath: path.join(base, 'config.yaml')
+  };
+}
+
+module.exports = {
+  buildGeneratedConfig,
+  getCanonicalProjection,
+  getDesignPaths,
+  readYaml,
+  stableJson,
+  writeYaml
+};

package/pro/squads/design/scripts/design-system/fetch_page_images.cjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/**
+ * Fetch visual screenshots of all Figma pages via Images API
+ * Saves PNG images for visual analysis
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+
+// Load .env
+const envPath = path.join(ROOT, '.env');
+if (fs.existsSync(envPath)) {
+  fs.readFileSync(envPath, 'utf8')
+    .replace(/\r/g, '')
+    .split('\n')
+    .forEach((line) => {
+      const m = line.match(/^([^#=]+)=(.*)$/);
+      if (m) process.env[m[1].trim()] = m[2].trim();
+    });
+}
+
+const TOKEN = process.env.FIGMA_API_KEY;
+const FILE_ID = process.env.FIGMA_FILE_ID;
+
+if (!TOKEN || !FILE_ID) {
+  console.error('Missing FIGMA_API_KEY or FIGMA_FILE_ID');
+  process.exit(1);
+}
+
+const MANIFEST_PATH = path.join(ROOT, 'workspace', 'domains', 'design-system', 'extraction', 'batch-manifest.json');
+const IMAGES_DIR = path.join(ROOT, 'workspace', 'domains', 'design-system', 'extraction', 'images');
+
+function figmaGet(endpoint) {
+  return new Promise((resolve, reject) => {
+    const url = 'https://api.figma.com/v1' + endpoint;
+    https.get(url, { headers: { 'X-Figma-Token': TOKEN }, timeout: 60000 }, (res) => {
+      if (res.statusCode === 429) {
+        const retryAfter = parseInt(res.headers['retry-after'] || '30', 10);
+        reject(new Error(`RATE_LIMITED:${retryAfter}`));
+        res.resume();
+        return;
+      }
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        try {
+          const body = JSON.parse(Buffer.concat(chunks).toString());
+          if (res.statusCode >= 400) {
+            reject(new Error(`API ${res.statusCode}: ${body.err || body.message || 'unknown'}`));
+          } else {
+            resolve(body);
+          }
+        } catch (e) {
+          reject(new Error('Parse failed'));
+        }
+      });
+    }).on('error', reject);
+  });
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const follow = (u) => {
+      const mod = u.startsWith('https') ? https : require('http');
+      mod.get(u, { timeout: 120000 }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          follow(res.headers.location);
+          res.resume();
+          return;
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          reject(new Error(`Download failed: ${res.statusCode}`));
+          return;
+        }
+        const stream = fs.createWriteStream(destPath);
+        res.pipe(stream);
+        stream.on('finish', () => {
+          stream.close();
+          resolve();
+        });
+        stream.on('error', reject);
+      }).on('error', reject);
+    };
+    follow(url);
+  });
+}
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+async function main() {
+  console.log('=== FIGMA PAGE IMAGE FETCHER ===\n');
+
+  const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+  const contentPages = manifest.pages.filter(p => p.status === 'success');
+
+  console.log(`Content pages to fetch: ${contentPages.length}`);
+  fs.mkdirSync(IMAGES_DIR, { recursive: true });
+
+  // Request one page at a time — large pages cause render timeouts in batches
+  // Sort smallest-first for faster initial results, then tackle large pages
+  const sortedPages = [...contentPages].sort((a, b) => (a.stats?.totalNodes || 0) - (b.stats?.totalNodes || 0));
+
+  let fetched = 0;
+  let errors = 0;
+  const errorList = [];
+
+  for (let i = 0; i < sortedPages.length; i++) {
+    const page = sortedPages[i];
+    const destPath = path.join(IMAGES_DIR, `${page.slug}.png`);
+    const nodes = page.stats?.totalNodes || 0;
+
+    // Skip if already downloaded
+    if (fs.existsSync(destPath) && fs.statSync(destPath).size > 100) {
+      console.log(`[${i + 1}/${sortedPages.length}] ✓ ${page.slug}: already exists`);
+      fetched++;
+      continue;
+    }
+
+    // Adaptive scale: very large pages get smaller scale
+    let scale = 0.25;
+    if (nodes > 50000) scale = 0.1;
+    else if (nodes > 20000) scale = 0.15;
+
+    console.log(`[${i + 1}/${sortedPages.length}] ${page.slug} (${nodes} nodes, scale=${scale})...`);
+
+    let success = false;
+    let retries = 0;
+    const maxRetries = 2;
+
+    while (!success && retries <= maxRetries) {
+      try {
+        const result = await figmaGet(`/images/${FILE_ID}?ids=${encodeURIComponent(page.nodeId)}&format=png&scale=${scale}`);
+
+        if (result.err) {
+          throw new Error(result.err);
+        }
+
+        const images = result.images || {};
+        const imgUrl = images[page.nodeId];
+
+        if (!imgUrl) {
+          console.log(`  ○ no image returned`);
+          break;
+        }
+
+        await downloadFile(imgUrl, destPath);
+        const size = fs.statSync(destPath).size;
+        console.log(`  ✓ ${Math.round(size / 1024)}KB`);
+        fetched++;
+        success = true;
+      } catch (err) {
+        if (err.message.startsWith('RATE_LIMITED:')) {
+          const waitSec = parseInt(err.message.split(':')[1], 10);
+          console.log(`  ⏳ Rate limited, waiting ${waitSec}s...`);
+          await sleep(waitSec * 1000);
+          retries++; // doesn't count as a retry
+        } else if (err.message.includes('timeout') || err.message.includes('Render')) {
+          // Try even smaller scale
+          scale = Math.max(0.05, scale / 2);
+          console.log(`  ⏳ Render timeout, retrying with scale=${scale}...`);
+          retries++;
+          await sleep(3000);
+        } else {
+          console.error(`  ✗ ${err.message}`);
+          errorList.push({ slug: page.slug, error: err.message });
+          errors++;
+          break;
+        }
+      }
+    }
+
+    if (!success && retries > maxRetries) {
+      console.error(`  ✗ Failed after ${maxRetries} retries`);
+      errorList.push({ slug: page.slug, error: 'max retries exceeded' });
+      errors++;
+    }
+
+    // Rate limit pause
+    await sleep(1500);
+  }
+
+  console.log(`\n=== DONE ===`);
+  console.log(`  Fetched: ${fetched}`);
+  console.log(`  Errors: ${errors}`);
+  console.log(`  Output: ${IMAGES_DIR}`);
+}
+
+main().catch(e => {
+  console.error('Failed:', e.message);
+  process.exit(1);
+});

package/pro/squads/design/scripts/design-system/generate_components_metadata.cjs

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const registryPath = path.join(ROOT, 'workspace/ui/registry.json');
+const outputPath = path.join(ROOT, 'workspace/domains/design-system/metadata/components.json');
+
+const DEFAULTS_BY_COMPONENT = {
+  button: {
+    agent_owner: 'brad-frost',
+    variants: ['default', 'secondary', 'outline', 'ghost', 'link'],
+    tokens: ['color.brand.primary', 'color.text.inverse', 'spacing.3', 'radius.md'],
+    a11y: {
+      role: 'button',
+      keyboard: ['Enter', 'Space'],
+      aria: ['aria-label (when icon-only)', 'aria-disabled'],
+      wcag: ['2.1.1', '2.4.7', '4.1.2']
+    }
+  },
+  input: {
+    agent_owner: 'brad-frost',
+    variants: ['default', 'error', 'disabled'],
+    tokens: ['color.surface.default', 'color.border.default', 'color.text.default', 'spacing.3', 'radius.md'],
+    a11y: {
+      role: 'textbox',
+      keyboard: ['Tab', 'Shift+Tab'],
+      aria: ['aria-label or associated label', 'aria-describedby', 'aria-invalid'],
+      wcag: ['1.3.1', '2.4.6', '3.3.1', '4.1.2']
+    }
+  }
+};
+
+function fail(message) {
+  console.error(`ERROR: ${message}`);
+  process.exit(1);
+}
+
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function safeReadJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    fail(`Unable to parse JSON at ${filePath}: ${error.message}`);
+  }
+}
+
+function inferComponent(item) {
+  const key = item.name;
+  const defaults = DEFAULTS_BY_COMPONENT[key] || {
+    agent_owner: 'design-chief',
+    variants: ['default'],
+    tokens: [],
+    a11y: {
+      role: 'generic',
+      keyboard: ['Tab'],
+      aria: [],
+      wcag: ['4.1.2']
+    }
+  };
+
+  return {
+    id: key,
+    name: item.title || key,
+    status: 'active',
+    version: '1.0.0',
+    agent_owner: defaults.agent_owner,
+    registryKey: key,
+    files: (item.files || []).map((file) => ({
+      path: file.path,
+      type: file.type || 'registry:component'
+    })),
+    variants: defaults.variants,
+    tokens: defaults.tokens,
+    a11y: defaults.a11y,
+    task_refs: ['ds-build-component', 'ds-sync-registry', 'ds-govern-a11y-compliance'],
+    template_refs: ['component-visual-spec-tmpl', 'component-prompt-injection-tmpl'],
+    workflow_refs: ['brownfield-complete', 'greenfield-new']
+  };
+}
+
+function main() {
+  if (!fs.existsSync(registryPath)) {
+    fail(`Registry not found: ${registryPath}`);
+  }
+
+  const registry = safeReadJson(registryPath);
+  const items = Array.isArray(registry.items) ? registry.items : [];
+
+  const components = items.map(inferComponent);
+  const payload = {
+    version: '1.0.0',
+    generatedAt: new Date().toISOString(),
+    source: {
+      registry: 'workspace/ui/registry.json',
+      generator: 'squads/design/scripts/design-system/generate_components_metadata.cjs'
+    },
+    components,
+    integrity: {
+      componentCount: components.length,
+      registryItemCount: items.length
+    }
+  };
+
+  ensureDir(outputPath);
+  fs.writeFileSync(outputPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  console.log(`PASS: Generated ${payload.integrity.componentCount} components at ${path.relative(ROOT, outputPath)}`);
+}
+
+main();