@mettlecast/domain-cli 0.2.2 → 0.2.4

package/dist/cli.js

@@ -30,6 +30,7 @@ import { runPowerTune } from './commands/power-tune.js';
 import { runReseedPage } from './commands/reseed-page.js';
 import { runAddSeedPage } from './commands/add-seed-page.js';
 import { runShowDns } from './commands/show-dns.js';
+import { runBuildUi } from './commands/build-ui.js';
 /**
  * Root CLI program for the TIB Domain Module local developer toolchain.
  * Provides build, validate, test, dev, add-domain, add-api, and add-subscriber subcommands.
@@ -174,7 +175,7 @@ program
 });
 program
     .command('add-page <pageId>')
-    .description('Scaffold a seed page from the dashboard-pages template registry')
+    .description('Scaffold a .page.json definition (default) or a pattern-based .tsx page component (--pattern)')
     .option('--output <dir>', 'Override the output directory (default: src/pages/<category>)')
     .option('--pattern <pattern>', 'Scaffold with a page pattern template (list, detail, form, wizard, dashboard, settings)')
     .option('--layout <layout>', 'Layout to use: app (default) or auth', 'app')
@@ -331,6 +332,13 @@ program
     .action(async (opts) => {
     await runShowDns(opts);
 });
+program
+    .command('build-ui')
+    .description('Scan frontend components and page definitions, write .mc/component-manifest.json and .mc/page-registry.json')
+    .option('--project-root <path>', 'Root of the project (defaults to cwd)')
+    .action(async (opts) => {
+    await runBuildUi({ projectRoot: opts.projectRoot });
+});
 program.parseAsync(process.argv).catch((err) => {
     // eslint-disable-next-line no-console
     console.error(err);

package/dist/commands/add-page.js

@@ -1,14 +1,7 @@
-import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
-import { join, resolve, dirname, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Readable } from 'node:stream';
-import { Parser as TarParser } from 'tar';
+import { writeFile, mkdir, access } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 import { cliLogger } from '../utils/logger.js';
-import { readScaffoldConfig } from '../utils/scaffold-config.js';
-import { fetchModulesJson, fetchModuleTarball } from '../utils/s3-fetch.js';
 import { PAGE_PATTERNS, listPageTemplate, detailPageTemplate, formPageTemplate, wizardPageTemplate, dashboardPageTemplate, settingsPageTemplate, } from '../templates/patterns/page/index.js';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const TEMPLATES_DIR = resolve(__dirname, '..', 'templates', 'dashboard-pages');
 /** Map from pattern name to its template function. */
 const PATTERN_TEMPLATES = {
     list: listPageTemplate,
@@ -19,137 +12,59 @@ const PATTERN_TEMPLATES = {
     settings: settingsPageTemplate,
 };
 const KEBAB_REGEX = /^[a-z][a-z0-9-]*$/;
-async function loadRegistry() {
-    // Dynamic import avoids tsx compilation issues with .tsx templates
-    const mod = await import('../templates/dashboard-pages/index.js');
-    return [...mod.PAGE_REGISTRY];
-}
-function getCategoryForPageId(pageId) {
-    const authPages = ['login', 'signup', 'verify-email', 'forgot-password', 'reset-password', 'mfa-setup', 'mfa-verify', 'choose-org', 'accept-invitation', 'sign-out'];
-    const accountPages = ['profile', 'workspace-settings', 'members', 'api-keys', 'audit-log'];
-    if (authPages.includes(pageId))
-        return 'auth';
-    if (accountPages.includes(pageId))
-        return 'account';
-    return 'shell';
-}
-async function fetchPageFromS3(scaffoldBucket, scaffoldVersion, pageId) {
-    try {
-        const modulesJson = await fetchModulesJson(scaffoldBucket, scaffoldVersion);
-        const frontendModule = modulesJson.modules.find(m => m.id === 'frontend');
-        if (!frontendModule) {
-            throw new Error(`Frontend module not found in modules.json for version ${scaffoldVersion}`);
-        }
-        const tarballBuffer = await fetchModuleTarball(scaffoldBucket, scaffoldVersion, frontendModule.tarball, frontendModule.sha256);
-        // Extract the page file from the tarball
-        const pageFileName = `${pageId}.tsx`;
-        const category = getCategoryForPageId(pageId);
-        const expectedPath = `frontend/src/pages/${category}/${pageFileName}`;
-        let content = '';
-        const chunks = [];
-        await new Promise((resolve, reject) => {
-            const parser = new TarParser({
-                onentry: (entry) => {
-                    if (entry.path === expectedPath) {
-                        entry.on('data', (chunk) => chunks.push(chunk));
-                    }
-                    else {
-                        entry.resume();
-                    }
-                },
-            });
-            parser.on('finish', resolve);
-            parser.on('error', reject);
-            Readable.from(tarballBuffer).pipe(parser);
-        });
-        if (chunks.length === 0) {
-            throw new Error(`Page template not found at ${expectedPath} in frontend tarball`);
-        }
-        content = Buffer.concat(chunks).toString('utf-8');
-        return content;
-    }
-    catch (err) {
-        cliLogger.warn(err, 'Failed to fetch from S3, falling back to local templates');
-        return null;
-    }
-}
-async function loadFromLocal(pageId, entry) {
-    const templatePath = join(TEMPLATES_DIR, entry.path);
-    try {
-        const content = await readFile(templatePath, 'utf8');
-        cliLogger.warn({ pageId }, 'Using local fallback template (scaffold version not available)');
-        return content;
-    }
-    catch {
-        throw new Error(`Template file not found at ${templatePath}`);
-    }
-}
 export async function runAddPage(opts) {
     const { pageId, pattern, layout = 'app' } = opts;
     if (!KEBAB_REGEX.test(pageId)) {
         throw new Error(`Invalid page id "${pageId}" — must be kebab-case`);
     }
-    // ── Pattern mode ──
-    if (pattern) {
-        if (!PAGE_PATTERNS.includes(pattern)) {
-            const available = PAGE_PATTERNS.join(', ');
-            throw new Error(`Unknown page pattern "${pattern}".\n\nAvailable patterns: ${available}`);
-        }
-        const templateFn = PATTERN_TEMPLATES[pattern];
-        let content = templateFn(pageId);
-        // Prepend layout comment
-        const layoutComment = `// Layout: ${layout === 'auth' ? 'AuthLayout' : 'AppLayout'} — import and use in your router config\n\n`;
-        content = layoutComment + content;
-        const outDir = opts.outputDir
+    // ── .page.json output mode (default when no pattern specified) ──
+    if (!pattern) {
+        const pageJsonContent = JSON.stringify({
+            id: pageId,
+            type: 'page',
+            route: `/${pageId}`,
+            tenancy: layout === 'auth' ? 'none' : 'required',
+            title: pageId.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+            layout: layout,
+            tokens: {},
+            regions: [],
+        }, null, 2) + '\n';
+        const pageJsonOutDir = opts.outputDir
             ? resolve(opts.outputDir)
-            : resolve(process.cwd(), 'src', 'pages', pageId);
-        await mkdir(outDir, { recursive: true });
-        const fileName = `${pageId}.tsx`;
-        const outPath = join(outDir, fileName);
-        // Refuse if target already exists
+            : resolve(process.cwd(), 'pages');
+        await mkdir(pageJsonOutDir, { recursive: true });
+        const pageJsonPath = join(pageJsonOutDir, `${pageId}.page.json`);
         try {
-            await access(outPath);
-            throw new Error(`File already exists at ${outPath}. Remove it first or use a different --output directory.`);
+            await access(pageJsonPath);
+            throw new Error(`File already exists at ${pageJsonPath}. Remove it first or use a different --output directory.`);
         }
         catch (err) {
             if (err.code !== 'ENOENT')
                 throw err;
         }
-        await writeFile(outPath, content, 'utf8');
-        cliLogger.info({ pageId, pattern, layout, outPath }, 'Page scaffolded from pattern');
+        await writeFile(pageJsonPath, pageJsonContent, 'utf8');
+        cliLogger.info({ pageId, layout, outPath: pageJsonPath }, 'Page .page.json scaffolded');
         // eslint-disable-next-line no-console
-        console.log(`\n✓ Page "${pageId}" (pattern: ${pattern}, layout: ${layout}) added at ${outPath}\n` +
-            `  Next: add a route in src/router.tsx for this page\n`);
+        console.log(`\n✓ Page "${pageId}" (layout: ${layout}) added at ${pageJsonPath}\n` +
+            `  Next: add the page in the page builder UI or edit the .page.json directly.\n` +
+            `  To add a route, update src/router.tsx.tpl.\n`);
         return;
     }
-    // ── Registry mode (existing behaviour) ──
-    const registry = await loadRegistry();
-    const entry = registry.find(p => p.id === pageId);
-    if (!entry) {
-        const available = registry.map(p => p.id).join(', ');
-        throw new Error(`Unknown page id "${pageId}".\n\nAvailable pages: ${available}\n` +
-            `Tip: use --pattern <pattern> to scaffold with a page pattern. Available patterns: ${PAGE_PATTERNS.join(', ')}`);
-    }
-    let content = null;
-    // Try S3 fetch first
-    try {
-        const config = await readScaffoldConfig(process.cwd());
-        if (config.scaffoldVersion && config.scaffoldBucket) {
-            content = await fetchPageFromS3(config.scaffoldBucket, config.scaffoldVersion, pageId);
-        }
-    }
-    catch (err) {
-        cliLogger.debug(err, 'Could not read scaffold config');
-    }
-    // Fall back to local templates
-    if (!content) {
-        content = await loadFromLocal(pageId, entry);
+    // ── Pattern mode ──
+    if (!PAGE_PATTERNS.includes(pattern)) {
+        const available = PAGE_PATTERNS.join(', ');
+        throw new Error(`Unknown page pattern "${pattern}".\n\nAvailable patterns: ${available}`);
     }
+    const templateFn = PATTERN_TEMPLATES[pattern];
+    let content = templateFn(pageId);
+    // Prepend layout comment
+    const layoutComment = `// Layout: ${layout === 'auth' ? 'AuthLayout' : 'AppLayout'} — import and use in your router config\n\n`;
+    content = layoutComment + content;
     const outDir = opts.outputDir
         ? resolve(opts.outputDir)
-        : resolve(process.cwd(), 'src', 'pages', entry.category);
+        : resolve(process.cwd(), 'src', 'pages', pageId);
     await mkdir(outDir, { recursive: true });
-    const fileName = `${basename(entry.path)}`;
+    const fileName = `${pageId}.tsx`;
     const outPath = join(outDir, fileName);
     // Refuse if target already exists
     try {
@@ -161,10 +76,8 @@ export async function runAddPage(opts) {
             throw err;
     }
     await writeFile(outPath, content, 'utf8');
-    cliLogger.info({ pageId, layout, outPath }, 'Page scaffolded');
+    cliLogger.info({ pageId, pattern, layout, outPath }, 'Page scaffolded from pattern');
     // eslint-disable-next-line no-console
-    console.log(`\n✓ Page "${pageId}" (layout: ${layout}) added at ${outPath}\n` +
-        `  Component: ${entry.name}\n` +
-        `  Next: import { ${entry.name} } from './${entry.category}/${basename(entry.path, '.tsx')}'\n` +
-        `  Then add a route in src/router.tsx\n`);
+    console.log(`\n✓ Page "${pageId}" (pattern: ${pattern}, layout: ${layout}) added at ${outPath}\n` +
+        `  Next: add a route in src/router.tsx for this page\n`);
 }

package/dist/commands/build-ui/component-scanner.d.ts

@@ -0,0 +1,12 @@
+export interface ComponentManifestEntry {
+    id: string;
+    displayName: string;
+    filePath: string;
+    propsSchema: Record<string, unknown>;
+    fixture?: unknown;
+    category: 'ui' | 'custom';
+}
+export declare function scanComponents(opts: {
+    uiDir: string;
+    customDir: string;
+}): Promise<ComponentManifestEntry[]>;

package/dist/commands/build-ui/component-scanner.js

@@ -0,0 +1,50 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+function kebabToPascal(kebab) {
+    return kebab
+        .split('-')
+        .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+}
+async function scanDir(dir, category) {
+    const entries = [];
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return entries;
+        }
+        throw err;
+    }
+    for (const file of files) {
+        if (file.endsWith('.tsx')) {
+            const id = file.slice(0, -4);
+            const displayName = kebabToPascal(id);
+            const filePath = join(dir, file);
+            const entry = {
+                id,
+                displayName,
+                filePath,
+                propsSchema: {},
+                category,
+            };
+            const fixtureFilePath = join(dir, `${id}.fixture.json`);
+            try {
+                const fixtureContent = await readFile(fixtureFilePath, 'utf8');
+                entry.fixture = JSON.parse(fixtureContent);
+            }
+            catch (err) {
+                // If fixture doesn't exist or can't be parsed, omit the field
+            }
+            entries.push(entry);
+        }
+    }
+    return entries;
+}
+export async function scanComponents(opts) {
+    const uiEntries = await scanDir(opts.uiDir, 'ui');
+    const customEntries = await scanDir(opts.customDir, 'custom');
+    return [...uiEntries, ...customEntries];
+}

package/dist/commands/build-ui/page-indexer.d.ts

@@ -0,0 +1,13 @@
+export interface PageRegistryEntry {
+    id: string;
+    route: string | null;
+    tenancy: string | null;
+    title: string | null;
+    tier: 1 | 2 | 3;
+    filePath: string;
+}
+export declare function indexPages(opts: {
+    pagesDir: string;
+    customDir: string;
+    frontendPagesDir: string;
+}): Promise<PageRegistryEntry[]>;

package/dist/commands/build-ui/page-indexer.js

@@ -0,0 +1,107 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+async function readPageJsonDir(dir) {
+    const entries = [];
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return entries;
+        }
+        throw err;
+    }
+    for (const file of files) {
+        if (file.endsWith('.page.json')) {
+            const filePath = join(dir, file);
+            try {
+                const content = await readFile(filePath, 'utf8');
+                const pageData = JSON.parse(content);
+                entries.push({
+                    id: pageData.id,
+                    route: pageData.route ?? null,
+                    tenancy: pageData.tenancy ?? null,
+                    title: pageData.title ?? null,
+                    tier: 1,
+                    filePath,
+                });
+            }
+            catch (err) {
+                // Skip malformed JSON files
+            }
+        }
+    }
+    return entries;
+}
+async function readCustomComponentsDir(dir) {
+    const entries = [];
+    let files;
+    try {
+        files = await readdir(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return entries;
+        }
+        throw err;
+    }
+    for (const file of files) {
+        if (file.endsWith('.tsx')) {
+            const id = file.slice(0, -4);
+            const filePath = join(dir, file);
+            entries.push({
+                id,
+                route: null,
+                tenancy: null,
+                title: null,
+                tier: 2,
+                filePath,
+            });
+        }
+    }
+    return entries;
+}
+async function walkFrontendPages(dir, baseDir) {
+    const entries = [];
+    let items;
+    try {
+        items = await readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return entries;
+        }
+        throw err;
+    }
+    for (const item of items) {
+        // Skip directories named _errors and shell
+        if (item.isDirectory() && (item.name === '_errors' || item.name === 'shell')) {
+            continue;
+        }
+        const itemPath = join(dir, item.name);
+        if (item.isDirectory()) {
+            const subEntries = await walkFrontendPages(itemPath, baseDir);
+            entries.push(...subEntries);
+        }
+        else if (item.name.endsWith('.tsx')) {
+            const relPath = relative(baseDir, itemPath);
+            const id = relPath.slice(0, -4);
+            entries.push({
+                id,
+                route: null,
+                tenancy: null,
+                title: null,
+                tier: 3,
+                filePath: itemPath,
+            });
+        }
+    }
+    return entries;
+}
+export async function indexPages(opts) {
+    const tier1 = await readPageJsonDir(opts.pagesDir);
+    const tier2 = await readCustomComponentsDir(opts.customDir);
+    const tier3 = await walkFrontendPages(opts.frontendPagesDir, opts.frontendPagesDir);
+    return [...tier1, ...tier2, ...tier3];
+}

package/dist/commands/build-ui.d.ts

@@ -0,0 +1,3 @@
+export declare function runBuildUi(opts: {
+    projectRoot?: string;
+}): Promise<void>;

package/dist/commands/build-ui.js

@@ -0,0 +1,23 @@
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { scanComponents } from './build-ui/component-scanner.js';
+import { indexPages } from './build-ui/page-indexer.js';
+export async function runBuildUi(opts) {
+    const projectRoot = opts.projectRoot ?? process.cwd();
+    const components = await scanComponents({
+        uiDir: join(projectRoot, 'frontend/src/components/ui'),
+        customDir: join(projectRoot, 'frontend/src/components/custom'),
+    });
+    const componentManifestPath = join(projectRoot, '.mc/component-manifest.json');
+    await mkdir(join(componentManifestPath, '..'), { recursive: true });
+    await writeFile(componentManifestPath, JSON.stringify(components, null, 2), 'utf8');
+    const pages = await indexPages({
+        pagesDir: join(projectRoot, 'pages'),
+        customDir: join(projectRoot, 'frontend/src/components/custom'),
+        frontendPagesDir: join(projectRoot, 'frontend/src/pages'),
+    });
+    const pageRegistryPath = join(projectRoot, '.mc/page-manifest.json');
+    await mkdir(join(pageRegistryPath, '..'), { recursive: true });
+    await writeFile(pageRegistryPath, JSON.stringify(pages, null, 2), 'utf8');
+    process.stderr.write(`[build-ui] Wrote ${components.length} components and ${pages.length} pages.\n`);
+}

package/dist/templates/api-skeleton.js

@@ -19,7 +19,7 @@ function camelCase(s) {
 export function apiSkeletonTemplate(domainId, apiId, tenancy) {
     const tenantPath = tenancy === 'required' ? '/v1/tenants/{tenantId}' : '/v1';
     return `import { z } from 'zod';
-import { defineApi } from '../../../lib/domain-runtime';
+import { defineApi } from '@mettlecast/domain-runtime';
 
 export const ${camelCase(apiId)} = defineApi({
   id: '${apiId}',

package/dist/templates/events-skeleton.js

@@ -8,7 +8,7 @@
  */
 export function eventsSkeletonTemplate(domainId) {
     return `import { z } from 'zod';
-import { defineEvent } from '../../../lib/domain-runtime';
+import { defineEvent } from '@mettlecast/domain-runtime';
 
 export const exampleEvent = defineEvent({
   id: '${domainId}.example',

package/dist/templates/subscriber-skeleton.js

@@ -9,7 +9,7 @@
  * @returns TypeScript source code as a string.
  */
 export function subscriberSkeletonTemplate(domainId, subscriberId, eventId) {
-    return `import { defineSubscriber } from '../../../lib/domain-runtime';
+    return `import { defineSubscriber } from '@mettlecast/domain-runtime';
 
 export const ${subscriberId.replace(/-([a-z])/g, (_, c) => c.toUpperCase())} = defineSubscriber({
   id: '${domainId}.${subscriberId}',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mettlecast/domain-cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/cli.ts

@@ -30,6 +30,7 @@ import { runPowerTune } from './commands/power-tune.js';
 import { runReseedPage } from './commands/reseed-page.js';
 import { runAddSeedPage } from './commands/add-seed-page.js';
 import { runShowDns } from './commands/show-dns.js';
+import { runBuildUi } from './commands/build-ui.js';
 
 /**
  * Root CLI program for the TIB Domain Module local developer toolchain.
@@ -198,7 +199,7 @@ program
 
 program
   .command('add-page <pageId>')
-  .description('Scaffold a seed page from the dashboard-pages template registry')
+  .description('Scaffold a .page.json definition (default) or a pattern-based .tsx page component (--pattern)')
   .option('--output <dir>', 'Override the output directory (default: src/pages/<category>)')
   .option('--pattern <pattern>', 'Scaffold with a page pattern template (list, detail, form, wizard, dashboard, settings)')
   .option('--layout <layout>', 'Layout to use: app (default) or auth', 'app')
@@ -380,6 +381,14 @@ program
     await runShowDns(opts);
   });
 
+program
+  .command('build-ui')
+  .description('Scan frontend components and page definitions, write .mc/component-manifest.json and .mc/page-registry.json')
+  .option('--project-root <path>', 'Root of the project (defaults to cwd)')
+  .action(async (opts: { projectRoot?: string }) => {
+    await runBuildUi({ projectRoot: opts.projectRoot });
+  });
+
 program.parseAsync(process.argv).catch((err: unknown) => {
   // eslint-disable-next-line no-console
   console.error(err);