@origostudio/origo-design 0.0.0

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

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import { entityCommand } from './entity';
+import { ejectTemplates } from '../../lib/generator';
+import { handleError } from '../../utils/errors';
+
+export function generateCommand(): Command {
+  const cmd = new Command('generate').description('Generate Origo artifacts');
+
+  cmd.addCommand(entityCommand());
+
+  cmd
+    .option('--eject', 'Copy internal templates to .origo/templates/ for customization')
+    .option('--force', 'Overwrite existing templates if they exist')
+    .option('--json', 'Output machine-readable JSON format')
+    .action(async (options: { eject?: boolean; force?: boolean; json?: boolean }) => {
+      if (options.eject) {
+        try {
+          await ejectTemplates({ force: options.force, json: options.json });
+        } catch (error: unknown) {
+          handleError(error, { json: options.json });
+        }
+      } else {
+        cmd.outputHelp();
+      }
+    });
+
+  return cmd;
+}

package/packages/cli/src/commands/init.ts

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import { scaffoldProject } from '../lib/scaffolding';
+import { handleError } from '../utils/errors';
+
+export function initCommand(): Command {
+  const init = new Command('init')
+    .description('Initialize a new Origo project (alias for origo new)')
+    .argument('<project-name>', 'Name of the project to initialize')
+    .option('--json', 'Output machine-readable JSON format')
+    .action(async (projectName: string, options: { json?: boolean }) => {
+      try {
+        await initializeProject(projectName, process.cwd(), options);
+      } catch (error) {
+        handleError(error, { json: options.json });
+      }
+    });
+
+  return init;
+}
+
+export async function initializeProject(
+  projectName: string,
+  targetPath: string = process.cwd(),
+  options: { json?: boolean } = {}
+): Promise<void> {
+  // Delegate directly to scaffoldProject to maintain single source of truth for scaffolding
+  await scaffoldProject(projectName, { ...options, cwd: targetPath });
+}

package/packages/cli/src/commands/new.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander';
+import { scaffoldProject } from '../lib/scaffolding';
+import { handleError } from '../utils/errors';
+
+export function newCommand(): Command {
+  const cmd = new Command('new');
+
+  cmd
+    .description('Scaffold a new Origo project')
+    .argument('<project-name>', 'Name of the project to scaffold')
+    .option('--json', 'Output machine-readable JSON format')
+    .action(async (projectName: string, options: { json?: boolean }) => {
+      try {
+        await scaffoldProject(projectName, { json: options.json });
+      } catch (error) {
+        handleError(error, { json: options.json });
+        process.exitCode = 1;
+      }
+    });
+
+  return cmd;
+}

package/packages/cli/src/commands/validate.ts

@@ -0,0 +1,47 @@
+import { Command } from 'commander';
+import { validateDirectory } from '../lib/validation';
+import { handleError, CliError } from '../utils/errors';
+
+export function validateCommand(): Command {
+  const cmd = new Command('validate');
+
+  cmd
+    .description('Validate BADL schemas in a directory or file')
+    .argument('[directory]', 'Directory or file containing BADL schemas to validate', './schemas')
+    .option('--json', 'Output machine-readable JSON format')
+    .action(async (directory: string, options: { json?: boolean }) => {
+      try {
+        const totalErrors = await validateDirectory(directory, { json: options.json });
+        if (totalErrors > 0) {
+          process.exitCode = 1;
+        }
+      } catch (error: unknown) {
+        if (options.json) {
+          const code = error instanceof CliError ? error.code : 'UNKNOWN_ERROR';
+          const message = error instanceof Error ? error.message : String(error);
+          const jsonOutput = {
+            status: 'error',
+            data: {
+              directory,
+              filesValidated: 0,
+              errorsFound: 1,
+              results: [
+                {
+                  file: directory,
+                  valid: false,
+                  errors: [{ code, message }],
+                },
+              ],
+            },
+          };
+          console.log(JSON.stringify(jsonOutput, null, 2));
+          process.exitCode = 1;
+        } else {
+          handleError(error, { json: false });
+          process.exitCode = 1;
+        }
+      }
+    });
+
+  return cmd;
+}

package/packages/cli/src/index.ts

@@ -0,0 +1,11 @@
+export * from './main';
+export * from './commands/new';
+export * from './commands/init';
+export * from './commands/validate';
+export * from './commands/generate';
+export * from './commands/generate/entity';
+export * from './lib/scaffolding';
+export * from './lib/validation';
+export * from './lib/generator';
+export * from './templates';
+export * from './utils/errors';

package/packages/cli/src/lib/cli.ts

@@ -0,0 +1,3 @@
+export function cli(): string {
+  return 'cli';
+}

package/packages/cli/src/lib/generator.ts

@@ -0,0 +1,181 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { CliError } from '../utils/errors';
+import { generateEntityTemplate } from '../templates';
+
+// FR-AI-005 Extensibility: Plugin registry for future AI integration
+export interface GeneratorPlugin {
+  resolveTemplate?(entityName: string): Promise<string | null>;
+  postGenerate?(context: { name: string; targetPath: string }): Promise<void>;
+}
+const plugins: GeneratorPlugin[] = [];
+export function registerGeneratorPlugin(plugin: GeneratorPlugin) {
+  plugins.push(plugin);
+}
+
+export async function generateEntity(
+  name: string,
+  options: { force?: boolean; json?: boolean }
+): Promise<void> {
+  if (!name || !name.trim()) {
+    throw new CliError({ code: 'ERR_INVALID_NAME', message: 'Entity name must not be empty.' });
+  }
+  if (/[/\\]/.test(name)) {
+    throw new CliError({
+      code: 'ERR_INVALID_NAME',
+      message: 'Entity name must not contain path separators.',
+    });
+  }
+
+  const targetDir = path.join(process.cwd(), 'schemas');
+  const targetPath = path.join(targetDir, name.toLowerCase() + '.json');
+  const userTemplatePath = path.join(process.cwd(), '.origo', 'templates', 'entity.json');
+  let content: string | null = null;
+
+  try {
+    await fs.access(targetPath);
+    if (!options.force) {
+      throw new CliError({
+        code: 'ERR_FILE_EXISTS',
+        message: `File already exists: ${targetPath}. Use --force to overwrite.`,
+        context: { path: targetPath },
+      });
+    }
+  } catch (error: unknown) {
+    if (error instanceof CliError) throw error;
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+
+  // FR-AI-005 Extensibility: Check plugins first
+  for (const plugin of plugins) {
+    if (plugin.resolveTemplate) {
+      const resolved = await plugin.resolveTemplate(name);
+      if (resolved) {
+        content = resolved;
+        break;
+      }
+    }
+  }
+
+  if (!content) {
+    try {
+      const rawTemplate = await fs.readFile(userTemplatePath, 'utf-8');
+      content =
+        rawTemplate.replace(/\{\{name\}\}/g, name).replace(/\{\{id\}\}/g, name.toLowerCase()) +
+        '\n';
+      // Validate user template output
+      try {
+        JSON.parse(content);
+      } catch {
+        throw new CliError({
+          code: 'ERR_INVALID_TEMPLATE',
+          message: `The user template at ${userTemplatePath} produced invalid JSON when substituted.`,
+        });
+      }
+    } catch (err: unknown) {
+      if (err instanceof CliError) throw err;
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code && code !== 'ENOENT') throw err;
+      content = generateEntityTemplate({ id: name.toLowerCase(), name });
+    }
+  }
+
+  try {
+    await fs.mkdir(targetDir, { recursive: true });
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err;
+  }
+
+  if (content === null) {
+    throw new CliError({ code: 'ERR_UNEXPECTED', message: 'Content is unexpectedly null.' });
+  }
+
+  await fs.writeFile(targetPath, content, 'utf-8');
+
+  // FR-AI-005 Extensibility: Post-generate hooks
+  for (const plugin of plugins) {
+    if (plugin.postGenerate) {
+      await plugin.postGenerate({ name, targetPath });
+    }
+  }
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          status: 'success',
+          data: {
+            file: `./schemas/${name.toLowerCase()}.json`,
+            entityName: name,
+          },
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(`Successfully generated entity ${name} at ./schemas/${name.toLowerCase()}.json`);
+  }
+}
+
+export async function ejectTemplates(options: { force?: boolean; json?: boolean }): Promise<void> {
+  const destDir = path.join(process.cwd(), '.origo', 'templates');
+  const srcDir = path.resolve(__dirname, '../templates');
+
+  let files: string[];
+  try {
+    files = await fs.readdir(srcDir);
+  } catch {
+    throw new CliError({ code: 'ERR_NO_TEMPLATES', message: 'No template files found to eject.' });
+  }
+
+  const jsonFiles = files.filter(f => f.endsWith('.json'));
+  if (jsonFiles.length === 0) {
+    throw new CliError({ code: 'ERR_NO_TEMPLATES', message: 'No template files found to eject.' });
+  }
+
+  if (!options.force) {
+    for (const file of jsonFiles) {
+      const destFile = path.join(destDir, file);
+      try {
+        await fs.access(destFile);
+        throw new CliError({
+          code: 'ERR_FILE_EXISTS',
+          message: `Template file already exists: ${destFile}. Use --force to overwrite.`,
+          context: { path: destFile },
+        });
+      } catch (err: unknown) {
+        if (err instanceof CliError) throw err;
+        if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+      }
+    }
+  }
+
+  try {
+    await fs.mkdir(destDir, { recursive: true });
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code !== 'EEXIST') throw err;
+  }
+
+  await Promise.all(
+    jsonFiles.map(file => fs.copyFile(path.join(srcDir, file), path.join(destDir, file)))
+  );
+
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          status: 'success',
+          data: {
+            destination: './.origo/templates',
+            filesEjected: jsonFiles,
+          },
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.log(`Successfully ejected ${jsonFiles.length} templates to ./.origo/templates`);
+  }
+}

package/packages/cli/src/lib/scaffolding.ts

@@ -0,0 +1,104 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { CliError } from '../utils/errors';
+import { generateOrigoConfig } from '../templates';
+
+export interface ScaffoldOptions {
+  json?: boolean;
+  cwd?: string;
+}
+
+export async function scaffoldProject(
+  projectName: string,
+  options: ScaffoldOptions = {}
+): Promise<void> {
+  // Guard against path traversal, empty input, or invalid directory names
+  if (
+    !projectName ||
+    path.basename(projectName) !== projectName ||
+    !/^[a-zA-Z0-9_.-]+$/.test(projectName)
+  ) {
+    throw new CliError({
+      code: 'ERR_INVALID_PROJECT_NAME',
+      message: `Invalid project name "${projectName}". Project name must be a single directory name without path traversal characters.`,
+      context: { projectName },
+    });
+  }
+
+  const baseDir = options.cwd ? path.resolve(options.cwd) : process.cwd();
+  const targetDir = path.resolve(baseDir, projectName);
+
+  // Check if directory already exists asynchronously
+  try {
+    await fs.access(targetDir);
+    throw new CliError({
+      code: 'EEXIST',
+      message: `Directory ${projectName} already exists.`,
+      context: { path: targetDir },
+    });
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    const isEnoent =
+      typeof error === 'object' &&
+      error !== null &&
+      'code' in error &&
+      (error as { code?: string }).code === 'ENOENT';
+    if (!isEnoent) {
+      throw new CliError({
+        code: 'SCAFFOLD_ERROR',
+        message: `Failed to inspect target directory: ${error instanceof Error ? error.message : String(error)}`,
+        context: { targetDir },
+        cause: error,
+      });
+    }
+  }
+
+  try {
+    const schemasDir = path.join(targetDir, 'schemas');
+    const configFile = path.join(targetDir, 'origo.json');
+
+    await fs.mkdir(targetDir, { recursive: true });
+    await fs.mkdir(schemasDir, { recursive: true });
+
+    // Sourced directly from secure-by-default templates built in Story 5.5.5
+    const configContent = generateOrigoConfig({
+      version: '1.0',
+      build: { outDir: './dist' },
+      schemas: './schemas',
+    });
+
+    await fs.writeFile(configFile, configContent, 'utf-8');
+
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: 'success',
+            data: {
+              projectName,
+              targetDir,
+              configFile,
+              schemasDir,
+            },
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(`Successfully initialized Origo project in ${targetDir}`);
+    }
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    throw new CliError({
+      code: 'SCAFFOLD_ERROR',
+      message: `Failed to scaffold project: ${error instanceof Error ? error.message : String(error)}`,
+      context: { projectName, targetDir, error },
+      cause: error,
+    });
+  }
+}

package/packages/cli/src/lib/validation.ts

@@ -0,0 +1,218 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { BADLValidator, validateAST } from '@origo/core';
+import { CliError } from '../utils/errors';
+
+export interface ValidationOptions {
+  json?: boolean;
+}
+
+export async function validateDirectory(
+  directory = './schemas',
+  options: ValidationOptions = {}
+): Promise<number> {
+  if (!directory || directory.trim() === '') {
+    throw new CliError({
+      code: 'ERR_INVALID_DIRECTORY',
+      message: 'Directory argument must not be empty.',
+    });
+  }
+  const cwd = process.cwd();
+  const targetDir = path.resolve(cwd, directory);
+  const relativePath = path.relative(cwd, targetDir);
+  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+    throw new CliError({
+      code: 'ERR_PATH_TRAVERSAL',
+      message: `Access denied: path "${directory}" resolves outside the working directory.`,
+      context: { directory, resolvedPath: targetDir, cwd },
+    });
+  }
+
+  let files: string[] = [];
+  let targetDirBase = targetDir;
+
+  try {
+    const stat = await fs.promises.stat(targetDir);
+    if (stat.isFile()) {
+      targetDirBase = path.dirname(targetDir);
+      files = [path.basename(targetDir)];
+      if (!files[0].endsWith('.json')) {
+        throw new CliError({
+          code: 'ERR_INVALID_FILE_TYPE',
+          message: 'Only .json files are supported for validation',
+        });
+      }
+    } else {
+      const dirents = await fs.promises.readdir(targetDir, {
+        recursive: true,
+        withFileTypes: true,
+      });
+      for (const d of dirents) {
+        if (d.isFile() && d.name.endsWith('.json')) {
+          const fullPath = path.join(d.parentPath || d.path, d.name);
+          files.push(path.relative(targetDirBase, fullPath));
+        }
+      }
+    }
+  } catch (error: unknown) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === 'ENOENT') {
+      throw new CliError({
+        code: 'ERR_DIRECTORY_NOT_FOUND',
+        message: `Path not found: ${directory}`,
+        cause: error,
+      });
+    }
+    throw new CliError({
+      code: 'ERR_DIRECTORY_READ',
+      message: `Failed to read path: ${err.message}`,
+      cause: error,
+    });
+  }
+
+  if (!options.json) {
+    console.log(`Validating schemas in ${directory}...\n`);
+  }
+
+  if (files.length === 0) {
+    if (!options.json) {
+      console.log('No .json files found.');
+    }
+    return 0;
+  }
+
+  const results = [];
+  let totalErrors = 0;
+
+  let validator: BADLValidator;
+  try {
+    validator = new BADLValidator();
+  } catch (error: unknown) {
+    throw new CliError({
+      code: 'ERR_VALIDATOR_INIT',
+      message: `Failed to initialize BADLValidator: ${error instanceof Error ? error.message : String(error)}`,
+      cause: error,
+    });
+  }
+
+  for (const file of files) {
+    const filePath = path.join(targetDirBase, file);
+    let rawContent: string;
+    let combinedErrors: Array<{ code: string; message: string; line?: number; column?: number }> =
+      [];
+    let isValid = true;
+
+    try {
+      rawContent = await fs.promises.readFile(filePath, 'utf-8');
+      rawContent = rawContent.replace(/^\uFEFF/, '');
+
+      const parsed = JSON.parse(rawContent);
+      const schemaType = parsed.$schema || '';
+
+      let isSchemaValid = false;
+      const schemaErrorsList: Array<{
+        code?: string;
+        message?: string;
+        context?: { line?: number; column?: number };
+      }> = [];
+      let astErrorsList: Array<{
+        type?: string;
+        message?: string;
+        line?: number;
+        column?: number;
+      }> = [];
+
+      if (schemaType.includes('domain.schema.json')) {
+        isSchemaValid = validator.validateDomain(rawContent);
+        if (validator.errors) schemaErrorsList.push(...validator.errors);
+
+        if (isSchemaValid) {
+          astErrorsList = validateAST({ schemaVersion: '1.0', domains: [parsed] });
+        }
+      } else if (schemaType.includes('entity.schema.json')) {
+        isSchemaValid = validator.validateEntity(rawContent);
+        if (validator.errors) schemaErrorsList.push(...validator.errors);
+      } else {
+        schemaErrorsList.push({
+          code: 'UNSUPPORTED_SCHEMA',
+          message: `Schema type is unsupported or missing $schema. Cannot validate: ${schemaType}`,
+        });
+      }
+
+      combinedErrors = [
+        ...schemaErrorsList.map(e => ({
+          code: e.code || 'VALIDATION_ERROR',
+          message: e.message || 'Unknown error',
+          line: e.context?.line,
+          column: e.context?.column,
+        })),
+        ...astErrorsList.map(e => ({
+          code: e.type || 'VALIDATION_ERROR',
+          message: e.message || 'Unknown error',
+          line: e.line,
+          column: e.column,
+        })),
+      ];
+
+      isValid = combinedErrors.length === 0;
+    } catch (error: unknown) {
+      combinedErrors = [
+        {
+          code: 'ERR_JSON_PARSE',
+          message: `Failed to parse JSON or read file ${file}: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ];
+      isValid = false;
+    }
+
+    totalErrors += combinedErrors.length;
+
+    results.push({
+      file,
+      valid: isValid,
+      errors: combinedErrors,
+    });
+  }
+
+  if (options.json) {
+    const jsonOutput = {
+      status: totalErrors === 0 ? 'success' : 'error',
+      data: {
+        directory,
+        filesValidated: files.length,
+        errorsFound: totalErrors,
+        results,
+      },
+    };
+    console.log(JSON.stringify(jsonOutput, null, 2));
+    return totalErrors;
+  }
+
+  let validFilesCount = 0;
+  let invalidFilesCount = 0;
+
+  for (const result of results) {
+    if (result.valid) {
+      console.log(`  \x1b[32m✓\x1b[0m  ${result.file}`);
+      validFilesCount++;
+    } else {
+      console.log(`  \x1b[31m✗\x1b[0m  ${result.file}`);
+      invalidFilesCount++;
+      for (const error of result.errors) {
+        const line = error.line !== undefined ? error.line : '-';
+        const col = error.column !== undefined ? error.column : '-';
+        console.log(`       ${line}:${col}  [${error.code}]  ${error.message}`);
+      }
+    }
+  }
+
+  const fileWord = (count: number) => (count === 1 ? 'file' : 'files');
+  console.log(
+    `\nFound ${totalErrors} errors in ${invalidFilesCount} ${fileWord(invalidFilesCount)} (${validFilesCount} ${fileWord(validFilesCount)} valid, ${invalidFilesCount} ${fileWord(invalidFilesCount)} invalid).`
+  );
+
+  return totalErrors;
+}

package/packages/cli/src/main.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init';
+import { newCommand } from './commands/new';
+import { validateCommand } from './commands/validate';
+import { generateCommand } from './commands/generate';
+import { handleError } from './utils/errors';
+
+export function createProgram(): Command {
+  const program = new Command();
+
+  program.name('origo').description('CLI for Origo Design').version('0.0.1');
+
+  program.addCommand(initCommand());
+  program.addCommand(newCommand());
+  program.addCommand(validateCommand());
+  program.addCommand(generateCommand());
+
+  return program;
+}
+
+export function main() {
+  const program = createProgram();
+
+  program.parseAsync(process.argv).catch(err => {
+    try {
+      handleError(err);
+    } catch (e) {
+      console.error('Fatal error in error handler:', e);
+    } finally {
+      process.exit(1);
+    }
+  });
+}
+
+if (require.main === module) {
+  main();
+}

package/packages/cli/src/templates/entity.json

@@ -0,0 +1,6 @@
+{
+  "id": "{{id}}",
+  "name": "{{name}}",
+  "implements": [],
+  "fields": []
+}