@origostudio/origo-design 0.0.0

package/packages/angular-renderer/src/components/primitives/text-input/text-input.component.pw.ts

@@ -0,0 +1,29 @@
+import { test, expect } from '@playwright/experimental-ct-angular';
+import { TextInputComponent, TextInputProps } from './text-input.component';
+import { InteractionContract } from '@origo/core';
+import AxeBuilder from '@axe-core/playwright';
+
+test.describe('TextInputComponent Accessibility', () => {
+  test('should not have any automatically detectable accessibility issues', async ({
+    mount,
+    page,
+  }) => {
+    await mount(TextInputComponent, {
+      props: {
+        contract: {
+          id: '2',
+          type: 'textInput',
+          props: {
+            placeholder: 'Enter name',
+            value: 'Jane',
+            'aria-label': 'Name input',
+            'aria-describedby': 'name-hint',
+          },
+        } as InteractionContract<TextInputProps>,
+      },
+    });
+
+    const accessibilityScanResults = await new AxeBuilder({ page }).analyze();
+    expect(accessibilityScanResults.violations).toEqual([]);
+  });
+});

package/packages/angular-renderer/src/components/primitives/text-input/text-input.component.scss

@@ -0,0 +1,42 @@
+:host {
+  display: inline-block;
+}
+input {
+  box-sizing: border-box;
+  width: 100%;
+  background-color: var(--origo-color-surface-background);
+  color: var(--origo-color-text-primary);
+  padding: var(--origo-spacing-container-padding);
+  border: var(--origo-border-width-default, 1px) solid var(--origo-color-border-default, #ccc);
+  border-radius: var(--origo-radius-sm, 4px);
+  box-shadow: var(--origo-shadow-sm, none);
+  font-family: var(--origo-typography-input-font-family, inherit);
+  font-size: var(--origo-typography-input-font-size, inherit);
+  font-weight: var(--origo-typography-input-font-weight, inherit);
+  line-height: var(--origo-typography-input-line-height, inherit);
+  transition: all 0.2s ease-in-out;
+}
+input::placeholder {
+  color: var(--origo-color-text-muted, #777);
+}
+input:hover:not(:disabled):not([readonly]) {
+  border-color: var(--origo-color-border-hover, #999);
+}
+input:active:not(:disabled):not([readonly]) {
+  border-color: var(--origo-color-border-active, #666);
+}
+input:focus,
+input:focus-visible {
+  outline: 2px solid var(--origo-color-focus, #005fcc);
+  outline-offset: -1px;
+  border-color: var(--origo-color-focus, #005fcc);
+}
+input:disabled {
+  cursor: not-allowed;
+  opacity: var(--origo-opacity-disabled, 0.5);
+  background-color: var(--origo-color-surface-disabled, #eee);
+  color: var(--origo-color-text-disabled, #999);
+}
+input[readonly] {
+  background-color: var(--origo-color-surface-readonly, #f9f9f9);
+}

package/packages/angular-renderer/src/components/primitives/text-input/text-input.component.ts

@@ -0,0 +1,84 @@
+import {
+  Component,
+  input,
+  model,
+  ChangeDetectionStrategy,
+  computed,
+  ViewEncapsulation,
+  inject,
+  effect,
+  untracked,
+  SecurityContext,
+} from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import { InteractionContract } from '@origo/core';
+import { OrigoAdapter } from '../../../adapters/web/adapter';
+import { WebExperienceAdapterService } from '../../../adapters/web/experience-adapter.service';
+
+export interface TextInputProps {
+  value?: string;
+  placeholder?: string;
+  disabled?: boolean;
+  readonly?: boolean;
+  'aria-label'?: string;
+  'aria-describedby'?: string;
+}
+
+@Component({
+  selector: 'origo-text-input',
+  standalone: true,
+  templateUrl: './text-input.component.html',
+  styleUrls: ['./text-input.component.scss'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.ShadowDom,
+  host: {
+    '[class.origo-text-input]': 'true',
+  },
+})
+export class TextInputComponent implements OrigoAdapter<TextInputProps> {
+  static readonly contractSchema = {
+    value: 'string',
+    placeholder: 'string',
+    disabled: 'boolean',
+    readonly: 'boolean',
+  };
+  static readonly strictContract = false;
+
+  contract = input.required<InteractionContract<TextInputProps>>();
+  value = model<string>('');
+
+  computedPlaceholder = computed(() => this.contract().props?.placeholder ?? '');
+  computedDisabled = computed(() => !!this.contract().props?.disabled);
+  computedReadonly = computed(() => !!this.contract().props?.readonly);
+  computedAriaLabel = computed(() => this.contract().props?.['aria-label'] as string | undefined);
+  computedAriaDescribedBy = computed(
+    () => this.contract().props?.['aria-describedby'] as string | undefined
+  );
+
+  private experienceAdapter = inject(WebExperienceAdapterService);
+  private sanitizer = inject(DomSanitizer);
+
+  constructor() {
+    effect(() => {
+      const contractVal = this.contract().props?.value;
+      untracked(() =>
+        this.value.set(contractVal !== undefined && contractVal !== null ? String(contractVal) : '')
+      );
+    });
+  }
+
+  onInput(event: Event) {
+    const target = event.target as HTMLInputElement | null;
+    if (!target) return;
+
+    const rawValue = target.value;
+    const sanitizedValue = this.sanitizer.sanitize(SecurityContext.HTML, rawValue) || '';
+
+    if (target.value !== sanitizedValue) {
+      target.value = sanitizedValue;
+    }
+
+    this.value.set(sanitizedValue);
+    this.experienceAdapter.updateState(this.contract().id, 'value', sanitizedValue);
+  }
+}

package/packages/angular-renderer/src/components/primitives/vbox/vbox.component.html

@@ -0,0 +1,2 @@
+<ng-container #vc></ng-container>
+<slot></slot>

package/packages/angular-renderer/src/components/primitives/vbox/vbox.component.pw.ts

@@ -0,0 +1,19 @@
+import { test, expect } from '@playwright/experimental-ct-angular';
+import { VBoxComponent } from './vbox.component';
+import AxeBuilder from '@axe-core/playwright';
+
+test.describe('VBoxComponent Accessibility', () => {
+  test('should not have any automatically detectable accessibility issues', async ({
+    mount,
+    page,
+  }) => {
+    await mount(VBoxComponent, {
+      props: {
+        contract: { id: '1', type: 'vbox', props: { gap: '10px' } } as never,
+      },
+    });
+
+    const accessibilityScanResults = await new AxeBuilder({ page }).analyze();
+    expect(accessibilityScanResults.violations).toEqual([]);
+  });
+});

package/packages/angular-renderer/src/components/primitives/vbox/vbox.component.scss

@@ -0,0 +1,5 @@
+:host {
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+}

package/packages/angular-renderer/src/components/primitives/vbox/vbox.component.ts

@@ -0,0 +1,74 @@
+import {
+  Component,
+  input,
+  viewChild,
+  ViewContainerRef,
+  ChangeDetectionStrategy,
+  computed,
+  ViewEncapsulation,
+} from '@angular/core';
+import { InteractionContract } from '@origo/core';
+import { OrigoAdapter, ContainerComponent } from '../../../adapters/web/adapter';
+
+export interface VBoxProps {
+  gap?: number | string;
+  alignment?: 'start' | 'center' | 'end' | 'stretch';
+  padding?: number | string;
+}
+
+@Component({
+  selector: 'origo-vbox',
+  standalone: true,
+  templateUrl: './vbox.component.html',
+  styleUrls: ['./vbox.component.scss'],
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  encapsulation: ViewEncapsulation.ShadowDom,
+  host: {
+    '[class.origo-vbox]': 'true',
+    '[style.gap]': 'computedGap()',
+    '[style.align-items]': 'computedAlignment()',
+    '[style.padding]': 'computedPadding()',
+  },
+})
+export class VBoxComponent implements OrigoAdapter<VBoxProps>, ContainerComponent {
+  static readonly contractSchema = {
+    gap: 'string',
+    alignment: 'string',
+    padding: 'string',
+  };
+  static readonly strictContract = false;
+
+  contract = input.required<InteractionContract<VBoxProps>>();
+
+  vc = viewChild.required('vc', { read: ViewContainerRef });
+
+  computedGap = computed(() => {
+    const gap = this.contract().props?.gap;
+    if (gap === undefined || gap === null || gap === '') return undefined;
+    const num = Number(gap);
+    return !isNaN(num) ? `${num}px` : String(gap);
+  });
+
+  computedAlignment = computed(() => {
+    const align = this.contract().props?.alignment;
+    switch (align) {
+      case 'start':
+        return 'flex-start';
+      case 'end':
+        return 'flex-end';
+      case 'center':
+        return 'center';
+      case 'stretch':
+        return 'stretch';
+      default:
+        return 'stretch';
+    }
+  });
+
+  computedPadding = computed(() => {
+    const padding = this.contract().props?.padding;
+    if (padding === undefined || padding === null || padding === '') return undefined;
+    const num = Number(padding);
+    return !isNaN(num) ? `${num}px` : String(padding);
+  });
+}

package/packages/angular-renderer/src/index.ts

@@ -0,0 +1,7 @@
+export * from './lib/theme.provider';
+export * from './lib/renderer.component';
+export * from './lib/renderer.tokens';
+export * from './adapters/web/adapter';
+export * from './components/primitives/vbox/vbox.component';
+export * from './components/primitives/text-input/text-input.component';
+export * from './components/primitives/button/button.component';

package/packages/angular-renderer/src/lib/renderer.component.ts

@@ -0,0 +1,118 @@
+import {
+  Component,
+  input,
+  inject,
+  ViewContainerRef,
+  effect,
+  viewChild,
+  DestroyRef,
+} from '@angular/core';
+import { ASTNode } from '@origo/core';
+import { RENDERER_REGISTRY } from './renderer.tokens';
+import { AdapterPipelineService, ContainerComponent } from '../adapters/web/adapter';
+
+@Component({
+  selector: 'origo-renderer',
+  standalone: true,
+  template: `<ng-container #vc></ng-container>`,
+})
+export class OrigoRendererComponent {
+  node = input.required<ASTNode>();
+  private registry = inject(RENDERER_REGISTRY, { optional: true }) ?? new Map();
+  private vc = viewChild.required('vc', { read: ViewContainerRef });
+  private destroyRef = inject(DestroyRef);
+  private adapter = inject(AdapterPipelineService);
+  private renderId = 0;
+  private isDestroyed = false;
+
+  constructor() {
+    this.destroyRef.onDestroy(() => (this.isDestroyed = true));
+    effect(() => {
+      const n = this.node();
+      const container = this.vc();
+      const currentId = ++this.renderId;
+      container.clear();
+      if (n) {
+        this.renderTree(n, container, currentId);
+      }
+    });
+  }
+
+  private async renderTree(rootNode: ASTNode, rootVc: ViewContainerRef, traversalId: number) {
+    const queue: { node: ASTNode; vc: ViewContainerRef }[] = [{ node: rootNode, vc: rootVc }];
+    const CHUNK_SIZE = 50;
+    const visited = new Set<string>();
+
+    while (queue.length > 0) {
+      if (this.isDestroyed || traversalId !== this.renderId) return;
+      let processed = 0;
+
+      while (queue.length > 0 && processed < CHUNK_SIZE) {
+        const item = queue.shift();
+        if (!item) continue;
+        processed++;
+        const { node, vc } = item;
+
+        if (visited.has(node.id)) continue;
+        visited.add(node.id);
+
+        const componentType = this.registry.get(node.type);
+
+        if (!componentType) {
+          console.warn(`No primitive found for node type: ${node.type}`);
+          if (node.children && node.children.length > 0) {
+            for (const child of node.children) {
+              if (child) queue.push({ node: child, vc });
+            }
+          }
+          continue;
+        }
+
+        const componentRef = vc.createComponent(componentType);
+
+        // Extract optional schema/strict mode if defined on the component class
+        const schema = (componentType as unknown as Record<string, unknown>)['contractSchema'] as
+          | Record<string, 'string' | 'number' | 'boolean' | 'array' | 'object'>
+          | undefined;
+        const strict =
+          (componentType as unknown as Record<string, unknown>)['strictContract'] === true;
+
+        const preparedNode = this.adapter.prepareNode(node, schema, strict);
+
+        if ('contract' in (componentRef.instance as Record<string, unknown>)) {
+          componentRef.setInput('contract', preparedNode);
+        } else {
+          console.warn(
+            `Component for ${node.type} does not implement OrigoAdapter (missing 'contract' input).`
+          );
+        }
+
+        if (node.children && node.children.length > 0) {
+          componentRef.changeDetectorRef.detectChanges();
+          const instance = componentRef.instance as ContainerComponent;
+          let childVc = instance.vc || instance.viewContainerRef;
+
+          if (typeof childVc === 'function') {
+            childVc = childVc();
+          }
+
+          if (childVc) {
+            for (const child of node.children) {
+              if (child) queue.push({ node: child, vc: childVc });
+            }
+          } else {
+            console.warn(
+              `Component for ${node.type} has children but does not expose a ViewContainerRef as 'vc'`
+            );
+          }
+        } else {
+          componentRef.changeDetectorRef.markForCheck();
+        }
+      }
+
+      if (queue.length > 0) {
+        await new Promise(resolve => setTimeout(resolve, 0));
+      }
+    }
+  }
+}

package/packages/angular-renderer/src/lib/renderer.tokens.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, Type } from '@angular/core';
+
+export const RENDERER_REGISTRY = new InjectionToken<Map<string, Type<unknown>>>(
+  'RENDERER_REGISTRY',
+  {
+    providedIn: 'root',
+    factory: () => new Map(),
+  }
+);

package/packages/angular-renderer/src/lib/test-utils.ts

@@ -0,0 +1,26 @@
+import { Type } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+export interface RenderPrimitiveOptions<T> {
+  component: Type<T>;
+  inputs?: Partial<T>;
+}
+
+export async function renderPrimitive<T>(
+  options: RenderPrimitiveOptions<T>
+): Promise<ComponentFixture<T>> {
+  await TestBed.configureTestingModule({
+    imports: [options.component],
+  }).compileComponents();
+
+  const fixture = TestBed.createComponent(options.component);
+
+  if (options.inputs) {
+    for (const [key, value] of Object.entries(options.inputs)) {
+      fixture.componentRef.setInput(key, value);
+    }
+  }
+
+  fixture.detectChanges();
+  return fixture;
+}

package/packages/angular-renderer/src/lib/theme.provider.ts

@@ -0,0 +1,83 @@
+import { APP_INITIALIZER, Provider, PLATFORM_ID, Optional } from '@angular/core';
+import { isPlatformBrowser, DOCUMENT } from '@angular/common';
+
+import { loadAndInjectTheme, injectTheme } from '@origo/design-tokens/runtime';
+
+export interface OrigoThemeOptions {
+  url?: string;
+  theme?: Record<string, unknown>;
+  targetElement?: HTMLElement | string;
+}
+
+export function themeInitializerFactory(
+  optionsOrUrl: string | OrigoThemeOptions,
+  platformId: object,
+  document: Document | null
+) {
+  return () => {
+    if (isPlatformBrowser(platformId)) {
+      const isString = typeof optionsOrUrl === 'string';
+      const url = isString ? optionsOrUrl : optionsOrUrl.url;
+      const theme = isString ? undefined : optionsOrUrl.theme;
+      // Resolve target element
+      let target: HTMLElement | undefined;
+      if (!isString && typeof optionsOrUrl.targetElement === 'string') {
+        target = document?.querySelector(optionsOrUrl.targetElement) as HTMLElement | undefined;
+        if (!target) {
+          console.warn(
+            `[origo-design] targetElement selector '${optionsOrUrl.targetElement}' matched nothing. Falling back to documentElement.`
+          );
+          target = document ? document.documentElement : undefined;
+        }
+      } else if (!isString && optionsOrUrl.targetElement instanceof HTMLElement) {
+        target = optionsOrUrl.targetElement;
+      } else {
+        target = document ? document.documentElement : undefined;
+      }
+
+      if (theme && url) {
+        const staticTeardown = injectTheme(theme, target);
+        return loadAndInjectTheme(url, target)
+          .then(fetchTeardown => {
+            return () => {
+              if (typeof staticTeardown === 'function') staticTeardown();
+              fetchTeardown();
+            };
+          })
+          .catch(e => {
+            console.error('[origo-design] theme init failed', e);
+            return typeof staticTeardown === 'function' ? staticTeardown : () => undefined;
+          });
+      } else if (theme) {
+        const teardown = injectTheme(theme, target);
+        return Promise.resolve(typeof teardown === 'function' ? teardown : () => undefined);
+      } else if (url) {
+        return loadAndInjectTheme(url, target).catch(e => {
+          console.error('[origo-design] theme init failed', e);
+          return () => undefined;
+        });
+      } else {
+        console.warn('[origo-design] options provided with neither theme nor url');
+        return Promise.resolve(() => undefined);
+      }
+    }
+    return Promise.resolve();
+  };
+}
+
+/**
+ * Provides the Origo Design theme initialization for the Angular Web Adapter.
+ *
+ * @param optionsOrUrl URL string to the theme.json file, or an options object configuring the theme.
+ */
+export function provideOrigoTheme(optionsOrUrl: string | OrigoThemeOptions): Provider[] {
+  return [
+    {
+      provide: APP_INITIALIZER,
+      useFactory: (platformId: object, document: Document | null) =>
+        themeInitializerFactory(optionsOrUrl, platformId, document),
+      deps: [PLATFORM_ID, [new Optional(), DOCUMENT]],
+      multi: true,
+    },
+  ];
+}

package/packages/angular-renderer/src/test-setup.ts

@@ -0,0 +1,8 @@
+import '@angular/compiler';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+
+getTestBed().initTestEnvironment(BrowserDynamicTestingModule, platformBrowserDynamicTesting());

package/packages/cli/CHANGELOG.md

@@ -0,0 +1,92 @@
+## 0.0.22 (2026-09-04)
+
+### 🚀 Features
+
+- scaffold playground application and e2e testing suite with initial editor component and schema registry ([f097894](https://github.com/OrigoStudio/origo-design/commit/f097894))
+- add GitHub Actions workflow to automate library releases using Nx Release ([3d6651f](https://github.com/OrigoStudio/origo-design/commit/3d6651f))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.21 (2026-09-02)
+
+### 🚀 Features
+
+- add centralized test registry tool with validation logic, CI integration, and documentation artifacts ([384c1c7](https://github.com/OrigoStudio/origo-design/commit/384c1c7))
+- implement central test registry with validation tools and CI integration ([02cf656](https://github.com/OrigoStudio/origo-design/commit/02cf656))
+- initialize negative testing story and update sprint status tracking ([bbe5fdc](https://github.com/OrigoStudio/origo-design/commit/bbe5fdc))
+- implement CLI framework with validation, testing, and CI/CD workflows ([ff6ce55](https://github.com/OrigoStudio/origo-design/commit/ff6ce55))
+- implement validate command and schema validation logic for BADL files ([4f9e41d](https://github.com/OrigoStudio/origo-design/commit/4f9e41d))
+- implement path traversal guards, remove process termination from library logic, and enable error cause preservation in @origo/cli ([0854f78](https://github.com/OrigoStudio/origo-design/commit/0854f78))
+- initialize web-based editor component and track security remediation tasks in implementation artifacts ([65716bd](https://github.com/OrigoStudio/origo-design/commit/65716bd))
+- document e2e npm verification plan for cli package releases ([22dab4c](https://github.com/OrigoStudio/origo-design/commit/22dab4c))
+- initialize sprint status tracking and retrospective verification story for npm packaging ([c326751](https://github.com/OrigoStudio/origo-design/commit/c326751))
+- add generated bundle for epic7-worker-csp spike ([16ca492](https://github.com/OrigoStudio/origo-design/commit/16ca492))
+- add web worker CSP spike and associated implementation documentation ([ebf5aa4](https://github.com/OrigoStudio/origo-design/commit/ebf5aa4))
+- implement web worker CSP spike with supporting documentation and harness tools ([f57b1e5](https://github.com/OrigoStudio/origo-design/commit/f57b1e5))
+- add technical spike story for Epic 7 web worker CSP validation and ADR planning ([c977487](https://github.com/OrigoStudio/origo-design/commit/c977487))
+- initialize sprint status tracking and create Epic 7 discovery research story ([b37b967](https://github.com/OrigoStudio/origo-design/commit/b37b967))
+- implement entity generator command with template customization and ejection support ([02a3193](https://github.com/OrigoStudio/origo-design/commit/02a3193))
+- implement entity generator command and template ejection logic in CLI ([d7d519a](https://github.com/OrigoStudio/origo-design/commit/d7d519a))
+- implementation of 6-2-local-schema-validation ([45e67f6](https://github.com/OrigoStudio/origo-design/commit/45e67f6))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.20 (2026-08-25)
+
+### 🚀 Features
+
+- implementation of 6-1-cli-initialization-and-scaffolding ([f6aca9e](https://github.com/OrigoStudio/origo-design/commit/f6aca9e))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.19 (2026-08-23)
+
+### 🚀 Features
+
+- 5.5-5-define-secure-by-default-boilerplate-templates ([0eb6dde](https://github.com/OrigoStudio/origo-design/commit/0eb6dde))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.18 (2026-08-23)
+
+### 🚀 Features
+
+- 5.5-4-verify-core-compiler-source-map-preservation ([a3b0d9b](https://github.com/OrigoStudio/origo-design/commit/a3b0d9b))
+
+### 🩹 Fixes
+
+- pipeline issue ([c1bbe47](https://github.com/OrigoStudio/origo-design/commit/c1bbe47))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.17 (2026-08-21)
+
+### 🚀 Features
+
+- 5.5-3-resolve-recursive-schema-resolution-tech-debt ([943e2e7](https://github.com/OrigoStudio/origo-design/commit/943e2e7))
+- 5.5-2-establish-end-to-end-qa-protocols ([d8990ae](https://github.com/OrigoStudio/origo-design/commit/d8990ae))
+- 5.5-2-establish-end-to-end-qa-protocols ([a31d97a](https://github.com/OrigoStudio/origo-design/commit/a31d97a))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse
+
+## 0.0.16 (2026-08-21)
+
+### 🚀 Features
+
+- 5.5-1-create-usability-quickstart-guide ([e740a1a](https://github.com/OrigoStudio/origo-design/commit/e740a1a))
+
+### ❤️ Thank You
+
+- Hardik Patel @hardikpatelse

package/packages/cli/README.md

@@ -0,0 +1,11 @@
+# cli
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build cli` to build the library.
+
+## Running unit tests
+
+Run `nx test cli` to execute the unit tests via [Jest](https://jestjs.io).

package/packages/cli/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@origo/cli",
+  "version": "0.0.22",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "bin": {
+    "origo": "./src/main.js"
+  },
+  "dependencies": {
+    "@origo/core": "0.0.22",
+    "commander": "^15.0.0",
+    "tslib": "^2.3.0"
+  }
+}

package/packages/cli/src/commands/generate/entity.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import { generateEntity } from '../../lib/generator';
+import { handleError } from '../../utils/errors';
+
+export function entityCommand(): Command {
+  const cmd = new Command('entity');
+  cmd
+    .description('Generate a new entity BADL schema')
+    .argument('<name>', 'Entity name (PascalCase, e.g. User)')
+    .option('--force', 'Overwrite existing file if it exists')
+    .option('--json', 'Output machine-readable JSON format')
+    .action(async (name: string, options: { force?: boolean; json?: boolean }) => {
+      try {
+        await generateEntity(name, { force: options.force, json: options.json });
+      } catch (error: unknown) {
+        handleError(error, { json: options.json });
+      }
+    });
+  return cmd;
+}