@ccslabs/xtend 0.1.0-rc.1

package/xtend-builder/lib/cli.d.ts

@@ -0,0 +1,9 @@
+import type { XtendBuilderCliArgs, XtendBuilderCliIo, XtendBuilderFlagArgs, XtendBuilderRecord } from '../builder-public-types';
+
+export declare const COMMAND_ALIASES: Readonly<Record<string, string>>;
+export declare function buildConfigSummary(): XtendBuilderRecord;
+export declare function buildHelpText(): string;
+export declare function normalizeCommand(command?: string | null): string | null;
+export declare function parseArgs(args?: string[]): XtendBuilderCliArgs;
+export declare function parseFlagArgs(args?: string[]): XtendBuilderFlagArgs;
+export declare function runCli(args?: string[], io?: XtendBuilderCliIo): number;

package/xtend-builder/lib/cli.js

@@ -0,0 +1,543 @@
+const config = require('../scaffold.config');
+const {
+  formatScaffoldLayout,
+  getScaffoldLayout
+} = require('./layout');
+const {
+  getComponentBlueprintContract
+} = require('../blueprints/component-blueprint.contract');
+const {
+  getGeneratorRegistry,
+  runGenerator
+} = require('../generators/registry');
+const {
+  getTemplateRegistry
+} = require('../templates/registry');
+const {
+  createDeveloperWorkflow,
+  createVerifyPlan
+} = require('../workflows/developer-workflow');
+const {
+  requireLocalOrScoped
+} = require('./package-resolver');
+const {
+  runRmtLinterCli
+} = requireLocalOrScoped(
+  __filename,
+  '../../tools/rmt-linter/cli',
+  '@ccslabs/xtend-compiler/rmt-linter/cli'
+);
+
+const CLI_SCHEMA = 'xtend.scaffold.cli.v1';
+const LAYOUT_SCHEMA = 'xtend.scaffold.layout.v1';
+const COMMAND_ALIASES = Object.freeze({
+  validate: 'verify'
+});
+
+function writeLine(stream, value = '') {
+  stream.write(`${value}\n`);
+}
+
+function parseArgs(args) {
+  const options = {
+    command: null,
+    help: false,
+    json: false,
+    rest: []
+  };
+
+  args.forEach((arg) => {
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+      return;
+    }
+
+    if (arg === '--json') {
+      options.json = true;
+      return;
+    }
+
+    if (!options.command) {
+      options.command = arg;
+      return;
+    }
+
+    options.rest.push(arg);
+  });
+
+  return options;
+}
+
+function normalizeCommand(command) {
+  return COMMAND_ALIASES[command] || command;
+}
+
+function parseFlagArgs(args) {
+  const parsed = {};
+  const positionals = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith('--')) {
+      positionals.push(arg);
+      continue;
+    }
+
+    const flag = arg.slice(2);
+    const equalsIndex = flag.indexOf('=');
+    let key = flag;
+    let value = true;
+
+    if (equalsIndex >= 0) {
+      key = flag.slice(0, equalsIndex);
+      value = flag.slice(equalsIndex + 1);
+    } else if (args[index + 1] && !args[index + 1].startsWith('--')) {
+      value = args[index + 1];
+      index += 1;
+    }
+
+    if (Object.prototype.hasOwnProperty.call(parsed, key)) {
+      parsed[key] = Array.isArray(parsed[key]) ? parsed[key].concat(value) : [parsed[key], value];
+    } else {
+      parsed[key] = value;
+    }
+  }
+
+  if (positionals.length > 0) {
+    parsed._ = positionals;
+  }
+
+  return parsed;
+}
+
+function buildHelpText() {
+  return [
+    'XTend-Scaffold CLI',
+    '',
+    'Usage:',
+    '  xt --help',
+    '  xt validate --json',
+    '  xt rmt lint app.rmt --json',
+    '  xt rmt lint tests/fixtures',
+    '  xt component-files --tag x-example --profile display --json',
+    '  xtend validate --json',
+    '  xtend rmt lint app.rmt',
+    '  xtend-scaffold verify --json',
+    '  node xtend-builder/scaffold.js --help',
+    '  node xtend-builder/scaffold.js layout',
+    '  node xtend-builder/scaffold.js layout --json',
+    '  node xtend-builder/scaffold.js blueprint --json',
+    '  node xtend-builder/scaffold.js generators --json',
+    '  node xtend-builder/scaffold.js templates --json',
+    '  node xtend-builder/scaffold.js component-plan --tag x-example --profile display --json',
+    '  node xtend-builder/scaffold.js component-files --tag x-example --profile display --json',
+    '  node xtend-builder/scaffold.js component-files --tag x-example --profile display --write --json',
+    '  node xtend-builder/scaffold.js component-files --tag x-example --profile display --check --json',
+    '  node xtend-builder/scaffold.js typing --tag x-example --profile display --json',
+    '  node xtend-builder/scaffold.js preview --tag x-example --profile display --json',
+    '  node xtend-builder/scaffold.js extensions --tag x-example --profile display --json',
+    '  node xtend-builder/scaffold.js rmt-lifecycle-demo --write --json',
+    '  node xtend-builder/scaffold.js rmt-build --source xtendrmt/rmt-lifecycle-demo.rmt --write --json',
+    '  node xtend-builder/scaffold.js workflow --json',
+    '  node xtend-builder/scaffold.js verify --json',
+    '  npm run scaffold -- layout',
+    '  npm run scaffold:workflow',
+    '  npm run scaffold:verify',
+    '  npm run scaffold:dry-run',
+    '  npm run scaffold:extensions',
+    '',
+    'Commands:',
+    '  help      Print this help text.',
+    '  layout    Print the reserved scaffold project layout.',
+    '  config    Print the current scaffold configuration summary.',
+    '  blueprint Print the component blueprint contract.',
+    '  generators Print the scaffold generator registry.',
+    '  templates Print the scaffold template registry.',
+    '  component-plan Create a dry-run component artifact plan.',
+    '  component-files Render component artifacts and optionally write them through WritePlan ownership guards.',
+    '  typing   Create the dry-run component type and XTendRMT attachment contract.',
+    '  preview  Create the dry-run component preview and reference-gate contract.',
+    '  extensions Create the dry-run templating, rendering and root-lifecycle extension contract.',
+    '  rmt-lifecycle-demo Compile the vNext RMT lifecycle template and build the generated demo app.',
+    '  rmt-build Compile an RMT vNext template into XTend app build artifacts.',
+    '  workflow  Print the local dry-run developer workflow.',
+    '  verify    Print the local scaffold verification plan.',
+    '  validate  Alias for verify.',
+    '  rmt lint  Lint native .rmt files and fallback .rmt.json files.',
+    '',
+    'Boundary:',
+    '  WP-E03-11 standardizes extension-point contracts without productive runtime code.',
+    '  Productive file writes must use the WP-E17-01 WritePlan writer and WP-E17-03 structured patchers.'
+  ].join('\n');
+}
+
+function buildConfigSummary() {
+  return {
+    schema: CLI_SCHEMA,
+    scaffoldName: config.scaffoldName,
+    role: config.scaffoldRole,
+    runtimeBoundary: config.runtimeBoundary,
+    entryPoints: config.entryPoints,
+    moduleLayout: config.moduleLayout,
+    blueprints: config.blueprints,
+    generators: config.generators,
+    templates: config.templateLoader,
+    typing: config.typing,
+    preview: config.preview,
+    rmtAppBuild: config.rmtAppBuild,
+    rmtCompatibility: config.rmtCompatibility,
+    extensions: config.extensions,
+    workflows: config.workflows,
+    wiring: config.wiring,
+    tooling: config.tooling
+  };
+}
+
+function printCommandList(stdout, title, commands) {
+  writeLine(stdout, title);
+  writeLine(stdout, '');
+  commands.forEach((entry) => {
+    writeLine(stdout, `${entry.id.padEnd(16)} ${entry.command}`);
+    writeLine(stdout, `  ${entry.purpose}`);
+  });
+}
+
+function runCli(args = process.argv.slice(2), io = {}) {
+  const stdout = io.stdout || process.stdout;
+  const stderr = io.stderr || process.stderr;
+  const options = parseArgs(args);
+  const command = normalizeCommand(options.command || (options.help ? 'help' : 'help'));
+
+  if (command === 'help' || (options.help && command !== 'rmt')) {
+    writeLine(stdout, buildHelpText());
+    return 0;
+  }
+
+  if (command === 'layout') {
+    const layout = getScaffoldLayout();
+    if (options.json) {
+      writeLine(stdout, JSON.stringify({
+        schema: LAYOUT_SCHEMA,
+        scaffoldName: config.scaffoldName,
+        layout
+      }, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, 'XTend-Scaffold Layout');
+    writeLine(stdout, '');
+    writeLine(stdout, formatScaffoldLayout(layout));
+    return 0;
+  }
+
+  if (command === 'config') {
+    const summary = buildConfigSummary();
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(summary, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `${summary.scaffoldName}: ${summary.role}`);
+    writeLine(stdout, `Runtime boundary: ${summary.runtimeBoundary}`);
+    writeLine(stdout, `CLI entry point: ${summary.entryPoints && summary.entryPoints.cli}`);
+    return 0;
+  }
+
+  if (command === 'blueprint') {
+    const blueprint = getComponentBlueprintContract();
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(blueprint, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, 'XTend-Scaffold Component Blueprint');
+    writeLine(stdout, '');
+    blueprint.artifacts.forEach((artifact) => {
+      writeLine(stdout, `${artifact.id.padEnd(10)} ${String(artifact.required).padEnd(11)} ${artifact.pathTemplate}`);
+    });
+    return 0;
+  }
+
+  if (command === 'generators') {
+    const registry = getGeneratorRegistry();
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(registry, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, 'XTend-Scaffold Generators');
+    writeLine(stdout, '');
+    registry.generators.forEach((generator) => {
+      writeLine(stdout, `${generator.command.padEnd(16)} ${generator.status.padEnd(10)} ${generator.description}`);
+    });
+    return 0;
+  }
+
+  if (command === 'templates') {
+    const registry = getTemplateRegistry();
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(registry, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, 'XTend-Scaffold Templates');
+    writeLine(stdout, '');
+    registry.templates.forEach((template) => {
+      writeLine(stdout, `${template.id.padEnd(26)} ${template.status.padEnd(22)} ${template.path}`);
+    });
+    return 0;
+  }
+
+  if (command === 'component-plan') {
+    const plan = runGenerator('component', parseFlagArgs(options.rest));
+    if (!plan.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(plan, null, 2));
+      } else {
+        plan.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(plan, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold Component Plan: ${plan.input.tag}`);
+    writeLine(stdout, '');
+    plan.artifacts.forEach((artifact) => {
+      writeLine(stdout, `${artifact.id.padEnd(10)} ${artifact.action.padEnd(11)} ${artifact.targetPath}`);
+    });
+    return 0;
+  }
+
+  if (command === 'component-files') {
+    const result = runGenerator('component-files', parseFlagArgs(options.rest));
+    if (!result.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(result, null, 2));
+      } else {
+        result.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(result, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold Component Files: ${result.input.tag}`);
+    writeLine(stdout, '');
+    result.files.forEach((file) => {
+      writeLine(stdout, `${file.id.padEnd(10)} ${file.targetPath}`);
+    });
+    return 0;
+  }
+
+  if (command === 'typing') {
+    const result = runGenerator('component-typing', parseFlagArgs(options.rest));
+    if (!result.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(result, null, 2));
+      } else {
+        result.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(result, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold Component Typing: ${result.component.tag}`);
+    writeLine(stdout, '');
+    writeLine(stdout, `${result.artifact.id.padEnd(10)} ${result.artifact.targetPath}`);
+    writeLine(stdout, `${'adapter'.padEnd(10)} ${result.rmtAttachment.adapter}`);
+    return 0;
+  }
+
+  if (command === 'preview') {
+    const result = runGenerator('component-preview', parseFlagArgs(options.rest));
+    if (!result.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(result, null, 2));
+      } else {
+        result.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(result, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold Component Preview: ${result.component.tag}`);
+    writeLine(stdout, '');
+    writeLine(stdout, `${result.artifact.id.padEnd(10)} ${result.artifact.targetPath}`);
+    writeLine(stdout, `${'registry'.padEnd(10)} ${result.registry.document}`);
+    return 0;
+  }
+
+  if (command === 'extensions') {
+    const result = runGenerator('component-extensions', parseFlagArgs(options.rest));
+    if (!result.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(result, null, 2));
+      } else {
+        result.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(result, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold Component Extensions: ${result.component.tag}`);
+    writeLine(stdout, '');
+    writeLine(stdout, `${'lifecycle'.padEnd(12)} ${result.rootLifecycle.schema}`);
+    writeLine(stdout, `${'template'.padEnd(12)} ${result.templating.adapter}`);
+    writeLine(stdout, `${'rendering'.padEnd(12)} ${result.rendering.scheduleHint}`);
+    return 0;
+  }
+
+  if (command === 'rmt-lifecycle-demo') {
+    const result = runGenerator('rmt-lifecycle-demo', parseFlagArgs(options.rest));
+    if (!result.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(result, null, 2));
+      } else {
+        result.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify({
+        ...result,
+        outputs: result.outputs.map((output) => ({
+          id: output.id,
+          path: output.path,
+          kind: output.kind,
+          generated: output.generated,
+          sha256: output.sha256
+        }))
+      }, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold RMT Lifecycle Demo: ${result.status}`);
+    writeLine(stdout, '');
+    result.outputs.forEach((output) => {
+      writeLine(stdout, `${output.id.padEnd(20)} ${output.path}`);
+    });
+    return 0;
+  }
+
+  if (command === 'rmt-build') {
+    const result = runGenerator('rmt-build', parseFlagArgs(options.rest));
+    if (!result.ok) {
+      if (options.json) {
+        writeLine(stdout, JSON.stringify(result, null, 2));
+      } else {
+        result.errors.forEach((error) => writeLine(stderr, error));
+      }
+      return 1;
+    }
+
+    if (options.json) {
+      writeLine(stdout, JSON.stringify({
+        ...result,
+        outputs: result.outputs.map((output) => ({
+          id: output.id,
+          path: output.path,
+          kind: output.kind,
+          generated: output.generated,
+          sha256: output.sha256
+        }))
+      }, null, 2));
+      return 0;
+    }
+
+    writeLine(stdout, `XTend-Scaffold RMT Build: ${result.status}`);
+    writeLine(stdout, '');
+    result.outputs.forEach((output) => {
+      writeLine(stdout, `${output.id.padEnd(20)} ${output.path}`);
+    });
+    return 0;
+  }
+
+  if (command === 'workflow') {
+    const workflow = createDeveloperWorkflow(parseFlagArgs(options.rest));
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(workflow, null, 2));
+      return 0;
+    }
+
+    printCommandList(stdout, 'XTend-Scaffold Developer Workflow', workflow.entryPoints);
+    return 0;
+  }
+
+  if (command === 'verify') {
+    const verifyPlan = createVerifyPlan(parseFlagArgs(options.rest));
+    if (options.json) {
+      writeLine(stdout, JSON.stringify(verifyPlan, null, 2));
+      return 0;
+    }
+
+    printCommandList(stdout, 'XTend-Scaffold Verify Plan', verifyPlan.commands);
+    return 0;
+  }
+
+  if (command === 'rmt') {
+    const subcommand = options.rest[0] || 'help';
+
+    if (subcommand === 'lint') {
+      const linterArgs = options.help ? options.rest.concat('--help') : options.rest;
+      return runRmtLinterCli(linterArgs, {
+        stdout,
+        stderr,
+        json: options.json,
+        rootDir: process.cwd()
+      });
+    }
+
+    if (subcommand === 'help' || options.help) {
+      writeLine(stdout, [
+        'XTend RMT Commands',
+        '',
+        'Usage:',
+        '  xt rmt lint app.rmt',
+        '  xt rmt lint app.rmt --json',
+        '  xt rmt lint tests/fixtures --fail-on warning',
+        '',
+        'Commands:',
+        '  lint  Run the native RMT linter.'
+      ].join('\n'));
+      return 0;
+    }
+
+    writeLine(stderr, `Unknown XTend RMT command: ${subcommand}`);
+    writeLine(stderr, 'Run `xt rmt --help` to see available RMT commands.');
+    return 1;
+  }
+
+  writeLine(stderr, `Unknown XTend-Scaffold command: ${command}`);
+  writeLine(stderr, 'Run `xt --help` or `node xtend-builder/scaffold.js --help` to see available commands.');
+  return 1;
+}
+
+module.exports = {
+  COMMAND_ALIASES,
+  buildConfigSummary,
+  buildHelpText,
+  normalizeCommand,
+  parseArgs,
+  parseFlagArgs,
+  runCli
+};

package/xtend-builder/lib/layout.d.ts

@@ -0,0 +1,6 @@
+import type { XtendBuilderConstant, XtendBuilderRecord } from '../builder-public-types';
+
+export declare const SCAFFOLD_LAYOUT: XtendBuilderConstant<XtendBuilderRecord[]>;
+export declare function formatScaffoldLayout(layout?: XtendBuilderRecord[]): string;
+export declare function getLayoutArea(id: string): XtendBuilderRecord | null;
+export declare function getScaffoldLayout(): XtendBuilderRecord[];

package/xtend-builder/lib/layout.js

@@ -0,0 +1,153 @@
+const SCAFFOLD_LAYOUT = [
+  {
+    id: 'root',
+    path: 'xtend-builder/',
+    kind: 'workspace',
+    owner: 'WP-E03-02',
+    purpose: 'Contains the XTend-Scaffold build-environment modules and local entry points.'
+  },
+  {
+    id: 'config',
+    path: 'xtend-builder/scaffold.config.js',
+    kind: 'config',
+    owner: 'WP-E03-01',
+    purpose: 'Central scaffold configuration for artifact paths, profiles, tooling and test obligation.'
+  },
+  {
+    id: 'cli',
+    path: 'xtend-builder/scaffold.js',
+    kind: 'entry-point',
+    owner: 'WP-E03-02',
+    purpose: 'Local Node/CommonJS CLI entry point for scaffold help, layout and future generator commands.'
+  },
+  {
+    id: 'cli-module',
+    path: 'xtend-builder/lib/cli.js',
+    kind: 'module',
+    owner: 'WP-E03-02',
+    purpose: 'CLI parser and command dispatcher without generator write behavior.'
+  },
+  {
+    id: 'layout-contract',
+    path: 'xtend-builder/lib/layout.js',
+    kind: 'module',
+    owner: 'WP-E03-02',
+    purpose: 'Machine-readable project layout contract used by docs, CLI and reference gates.'
+  },
+  {
+    id: 'generators',
+    path: 'xtend-builder/generators/',
+    kind: 'module-directory',
+    owner: 'WP-E03-04',
+    purpose: 'Future generator implementations. WP-02 only reserves the boundary.'
+  },
+  {
+    id: 'blueprints',
+    path: 'xtend-builder/blueprints/',
+    kind: 'contract-directory',
+    owner: 'WP-E03-03',
+    purpose: 'Future component blueprint and artifact-contract definitions.'
+  },
+  {
+    id: 'templates',
+    path: 'xtend-builder/templates/',
+    kind: 'template-directory',
+    owner: 'WP-E03-04',
+    purpose: 'Future file templates loaded by generators after blueprint approval.'
+  },
+  {
+    id: 'wiring',
+    path: 'xtend-builder/wiring/',
+    kind: 'contract-directory',
+    owner: 'WP-E03-06',
+    purpose: 'Manifest and hydration wiring contracts used by dry-run component output.'
+  },
+  {
+    id: 'typing',
+    path: 'xtend-builder/typing/',
+    kind: 'contract-directory',
+    owner: 'WP-E03-09',
+    purpose: 'Type contracts for scaffolded components and prepared XTendRMT adapter attachment.'
+  },
+  {
+    id: 'preview',
+    path: 'xtend-builder/preview/',
+    kind: 'contract-directory',
+    owner: 'WP-E03-10',
+    purpose: 'Preview and reference-path contracts for scaffolded component demo plans.'
+  },
+  {
+    id: 'extensions',
+    path: 'xtend-builder/extensions/',
+    kind: 'contract-directory',
+    owner: 'WP-E03-11',
+    purpose: 'Templating, rendering and root-lifecycle extension-point contracts for scaffolded components.'
+  },
+  {
+    id: 'a11y',
+    path: 'xtend-builder/a11y/',
+    kind: 'contract-directory',
+    owner: 'ER-WP-23',
+    purpose: 'A11y profile plan contracts used by component blueprints, templates, fixtures and reference gates.'
+  },
+  {
+    id: 'performance',
+    path: 'xtend-builder/performance/',
+    kind: 'contract-directory',
+    owner: 'ER-WP-21',
+    purpose: 'Performance profile plan contracts used by component blueprints, templates, manifests and reference gates.'
+  },
+  {
+    id: 'workflows',
+    path: 'xtend-builder/workflows/',
+    kind: 'workflow-directory',
+    owner: 'WP-E03-08',
+    purpose: 'Local dry-run and verification workflow contracts for developers and AI agents.'
+  },
+  {
+    id: 'writing',
+    path: 'xtend-builder/writing/',
+    kind: 'writer-directory',
+    owner: 'WP-E17-03',
+    purpose: 'Central WritePlan, structured patchers and controlled file-write helpers for productive Scaffold builds.'
+  },
+  {
+    id: 'utils',
+    path: 'xtend-builder/utils/',
+    kind: 'helper-directory',
+    owner: 'WP-E03-04',
+    purpose: 'Future pure helpers for paths, validation, planning and conflict checks.'
+  }
+];
+
+function cloneLayoutArea(area) {
+  return {
+    id: area.id,
+    path: area.path,
+    kind: area.kind,
+    owner: area.owner,
+    purpose: area.purpose
+  };
+}
+
+function getScaffoldLayout() {
+  return SCAFFOLD_LAYOUT.map(cloneLayoutArea);
+}
+
+function getLayoutArea(id) {
+  const area = SCAFFOLD_LAYOUT.find((candidate) => candidate.id === id);
+  return area ? cloneLayoutArea(area) : null;
+}
+
+function formatScaffoldLayout(layout = getScaffoldLayout()) {
+  return layout
+    .map((area) => `${area.id.padEnd(16)} ${area.path.padEnd(38)} ${area.kind}`)
+    .join('\n');
+}
+
+module.exports = {
+  SCAFFOLD_LAYOUT,
+  formatScaffoldLayout,
+  getLayoutArea,
+  getScaffoldLayout
+};