@researchdatabox/redbox-dev-tools 0.0.1-beta.8936

package/dist/cli.js

@@ -0,0 +1,464 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const paths_1 = require("./utils/paths");
+const hook_archetype_1 = require("./templates/hook-archetype");
+const form_config_1 = require("./commands/form-config");
+const completion_1 = require("./completion");
+const cli_parsers_1 = require("./cli-parsers");
+const program = new commander_1.Command();
+// List of dependencies that are common in our legacy hooks but should not be in modern hook packages as they are supplied by redbox-core
+const forbiddenHookDeps = ['axios', 'rxjs', 'lodash', 'mocha', 'chai', 'ts-node', 'typescript'];
+const allowedSharedHookDeps = {
+    dependencies: new Set(),
+    devDependencies: new Set(['@researchdatabox/redbox-dev-tools']),
+    peerDependencies: new Set(['@researchdatabox/redbox-core']),
+};
+function readPackageJson(pkgPath) {
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+}
+function writePackageJson(pkgPath, pkg) {
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+function isForbiddenSharedHookDep(section, depName) {
+    if (!depName.startsWith('@researchdatabox/')) {
+        return false;
+    }
+    return !allowedSharedHookDeps[section].has(depName);
+}
+function migrateHookDependencyContract(pkg) {
+    const nextPkg = { ...pkg };
+    nextPkg.dependencies = { ...(pkg.dependencies ?? {}) };
+    nextPkg.devDependencies = { ...(pkg.devDependencies ?? {}) };
+    nextPkg.peerDependencies = { ...(pkg.peerDependencies ?? {}) };
+    for (const section of Object.keys(allowedSharedHookDeps)) {
+        for (const depName of Object.keys(nextPkg[section] ?? {})) {
+            if (isForbiddenSharedHookDep(section, depName)) {
+                delete nextPkg[section][depName];
+            }
+        }
+    }
+    for (const depName of forbiddenHookDeps) {
+        delete nextPkg.dependencies[depName];
+        delete nextPkg.devDependencies[depName];
+        delete nextPkg.peerDependencies[depName];
+    }
+    nextPkg.peerDependencies['@researchdatabox/redbox-core'] = nextPkg.peerDependencies['@researchdatabox/redbox-core'] ?? '*';
+    nextPkg.devDependencies['@researchdatabox/redbox-dev-tools'] = nextPkg.devDependencies['@researchdatabox/redbox-dev-tools'] ?? '*';
+    return nextPkg;
+}
+function findForbiddenHookDeps(pkg) {
+    const sections = ['dependencies', 'devDependencies', 'peerDependencies'];
+    const findings = [];
+    for (const section of sections) {
+        const deps = pkg[section] ?? {};
+        for (const depName of Object.keys(deps)) {
+            if (isForbiddenSharedHookDep(section, depName)) {
+                findings.push(`${section}.${depName}`);
+            }
+        }
+        for (const depName of forbiddenHookDeps) {
+            if (deps[depName] != null) {
+                findings.push(`${section}.${depName}`);
+            }
+        }
+    }
+    return findings;
+}
+program
+    .name('redbox-dev-tools')
+    .description('CLI for ReDBox hook development and code generation')
+    .version('1.0.0')
+    .option('--root <path>', 'ReDBox repo root directory (required for generators)')
+    .option('--core-types-root <path>', 'Override core-types package root')
+    .option('--angular-root <path>', 'Override angular projects root')
+    .option('--dry-run', 'Print intended changes without writing files', false);
+function resolveSkillsDir() {
+    return path.resolve(__dirname, '..', 'skills');
+}
+program
+    .command('completion <shell>')
+    .description('Output shell completion script for bash, zsh, fish, or powershell')
+    .action((shell) => {
+    const normalized = shell.toLowerCase();
+    try {
+        const script = (0, completion_1.generateCompletionScript)(normalized);
+        process.stdout.write(script);
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+(0, form_config_1.registerMigrateFormConfigCommand)(program);
+(0, form_config_1.registerMigrateDataClassificationCommand)(program);
+(0, form_config_1.registerClientFormConfigCommand)(program);
+(0, form_config_1.registerQuestionTreeDiagramCommand)(program);
+program
+    .command('init [name]')
+    .description('Initialize a new ReDBox hook project from the standard archetype')
+    .option('--template <template>', 'Archetype template name', 'standard')
+    .option('--description <description>', 'Project description')
+    .option('--force', 'Overwrite existing archetype files', false)
+    .action((name, options) => {
+    if (options.template !== 'standard') {
+        console.error(`❌ Unsupported template: ${options.template}. Supported templates: standard`);
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const packageName = name || path.basename(cwd);
+    console.log(`🚀 Initializing ReDBox hook archetype for ${packageName}...\n`);
+    const result = (0, hook_archetype_1.generateHookArchetype)({
+        cwd,
+        packageName,
+        description: options.description,
+        force: options.force,
+        templateName: options.template,
+    });
+    for (const createdPath of result.created) {
+        console.log(`✅ Created ${createdPath}`);
+    }
+    for (const skippedPath of result.skipped) {
+        console.log(`ℹ️  Skipped existing ${skippedPath}`);
+    }
+    console.log('\n✨ Archetype ready!\n');
+    console.log('Next steps:');
+    console.log('  1. Install dependencies: npm install');
+    console.log('  2. Compile TypeScript: npm run compile');
+    console.log('  3. Run unit tests: npm run test:unit');
+    console.log('  4. Start tailoring the hook in src/, test/, and support/\n');
+});
+program
+    .command('check')
+    .description('Validate that a hook uses the shared Redbox dependency contract')
+    .action(() => {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        console.error('❌ package.json not found in the current directory.');
+        process.exit(1);
+    }
+    const pkg = readPackageJson(packageJsonPath);
+    const findings = findForbiddenHookDeps(pkg);
+    if (findings.length === 0) {
+        console.log('✅ Hook dependency contract looks good.');
+        return;
+    }
+    console.error('❌ Hook dependency contract violations found:');
+    for (const finding of findings) {
+        console.error(`  - ${finding}`);
+    }
+    console.error('Shared runtime dependencies should come from @researchdatabox/redbox-core, and shared toolchain dependencies should come from @researchdatabox/redbox-dev-tools.');
+    process.exit(1);
+});
+program
+    .command('migrate-hook-dependencies')
+    .description('Rewrite the current hook package.json to the minimal shared dependency contract')
+    .action(() => {
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        console.error('❌ package.json not found in the current directory.');
+        process.exit(1);
+    }
+    const pkg = readPackageJson(packageJsonPath);
+    const migratedPkg = migrateHookDependencyContract(pkg);
+    writePackageJson(packageJsonPath, migratedPkg);
+    console.log('✅ Updated package.json to use the minimal shared hook dependency contract.');
+});
+const generate = program.command('generate').alias('g').description('Generate code components');
+generate
+    .command('controller <name>')
+    .description('Generate a new ReDBox controller')
+    .option('--actions <actions>', 'Comma-separated list of actions', val => val.split(','))
+    .option('--webservice', 'Generate as a webservice controller', false)
+    .option('--class-name <className>', 'Override controller class name (defaults to name without Controller suffix)')
+    .option('--route <route>', 'Single route (deprecated, use --routes)')
+    .option('--routes <routes>', 'Action-to-route mappings: action:verb:path[:role1:role2],... (e.g., list:get:/api/items:Admin:Researcher,delete:delete:/api/items/:id:Admin)', cli_parsers_1.parseRoutes)
+    .option('--nav <nav>', 'Navigation mappings: action:type[:containerId]:labelKey[:itemId],... (e.g., list:menu:plan:create-rdmp:plan-create)', cli_parsers_1.parseNavMappings)
+    .option('--lang <lang>', 'Language defaults: key=value[:lang],... (e.g., menu-custom=Custom menu:en)', cli_parsers_1.parseLanguageDefaults)
+    .option('--auth <roles>', 'Default roles for auth rules (can be overridden per-route)', val => val.split(','))
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { ControllerGenerator } = require('./generators/controller');
+        const generator = new ControllerGenerator({
+            name,
+            actions: options.actions,
+            webservice: options.webservice,
+            route: options.route,
+            routes: options.routes,
+            auth: options.auth,
+            navigation: options.nav,
+            languageDefaults: options.lang,
+            className: options.className,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Generating controller: ${name}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+generate
+    .command('service <name>')
+    .description('Generate a new ReDBox service')
+    .option('--methods <methods>', 'Comma-separated list of methods', val => val.split(','))
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { ServiceGenerator } = require('./generators/service');
+        const generator = new ServiceGenerator({
+            name,
+            methods: options.methods,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Generating service: ${name}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+generate
+    .command('method')
+    .description('Add a method to an existing controller or service')
+    .requiredOption('--file <path>', 'Path to existing controller or service file')
+    .requiredOption('--method <name>', 'Method name to add')
+    .option('--route <route>', 'Route path (for controllers)')
+    .option('--http <verb>', 'HTTP verb (GET, POST, etc.)')
+    .option('--auth <roles>', 'Comma-separated list of roles', val => val.split(','))
+    .option('--nav <nav>', 'Navigation mappings: type[:containerId]:labelKey[:itemId],... (e.g., menu:plan:create-rdmp:plan-create)', cli_parsers_1.parseNavMappings)
+    .option('--lang <lang>', 'Language defaults: key=value[:lang],... (e.g., menu-custom=Custom menu:en)', cli_parsers_1.parseLanguageDefaults)
+    .action(async (options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { AddMethodGenerator } = require('./generators/add-method');
+        const generator = new AddMethodGenerator({
+            file: options.file,
+            method: options.method,
+            route: options.route,
+            http: options.http,
+            auth: options.auth,
+            navigation: options.nav,
+            languageDefaults: options.lang,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Adding method ${options.method} to ${options.file}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+generate
+    .command('angular-app <name>')
+    .description('Scaffold a new Angular app for embedded EJS usage')
+    .requiredOption('--ejs-view <view>', 'EJS view name')
+    .option('--auth <roles>', 'Comma-separated list of roles', val => val.split(','))
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { AngularAppGenerator } = require('./generators/angular-app');
+        const generator = new AngularAppGenerator({
+            name,
+            ejsView: options.ejsView,
+            auth: options.auth,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Generating Angular app: ${name}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+generate
+    .command('angular-service <name>')
+    .description('Generate a new Angular service extending HttpClientService')
+    .requiredOption('--app <app>', 'Target Angular app name')
+    .option('--methods <methods>', 'Comma-separated list of methods', val => val.split(','))
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { AngularServiceGenerator } = require('./generators/angular-service');
+        const generator = new AngularServiceGenerator({
+            name,
+            app: options.app,
+            methods: options.methods,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Generating Angular service: ${name} for app ${options.app}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+generate
+    .command('form-component <name>')
+    .description('Generate scaffold for a new form component across Angular and sails-ng-common')
+    .option('--app <app>', 'Target Angular app name', 'form')
+    .option('--with-service', 'Also generate a companion Angular HttpClient service', false)
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { FormComponentGenerator } = require('./generators/form-component');
+        const generator = new FormComponentGenerator({
+            name,
+            app: options.app,
+            withService: options.withService,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Generating form component scaffold: ${name}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+generate
+    .command('form-field <name>')
+    .description('Generate a new form field DSL configuration')
+    .requiredOption('--type <type>', 'Record type')
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { FormFieldGenerator } = require('./generators/form-field');
+        const generator = new FormFieldGenerator({
+            name,
+            type: options.type,
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+        });
+        console.log(`\n🛠️  Generating form field config: ${name}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+program
+    .command('install-skills')
+    .alias('skills')
+    .description('Install bundled agent skills using the vercel-labs skills CLI')
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .action(() => {
+    const skillsDir = resolveSkillsDir();
+    if (!fs.existsSync(skillsDir)) {
+        console.error(`Skills directory not found: ${skillsDir}`);
+        process.exit(1);
+    }
+    const rawArgs = process.argv.slice(2);
+    const cmdIndex = rawArgs.findIndex(arg => arg === 'install-skills' || arg === 'skills');
+    const forwardedArgs = cmdIndex === -1 ? [] : rawArgs.slice(cmdIndex + 1);
+    const result = (0, child_process_1.spawnSync)('npx', ['skills', 'add', skillsDir, ...forwardedArgs], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+    });
+    if (result.error) {
+        console.error('Failed to run npx skills:', result.error.message);
+        process.exit(1);
+    }
+    process.exit(result.status === null ? 1 : result.status);
+});
+generate
+    .command('model <name>')
+    .description('Generate a new Waterline model with decorator-based definition')
+    .option('--identity <identity>', 'Waterline identity (table name), defaults to lowercase name')
+    .option('--attrs <attrs>', 'Comma-separated list of attributes in format name:type[:required][:unique]', cli_parsers_1.parseAttributes)
+    .option('--belongs-to <associations>', 'Comma-separated belongsTo associations in format name:model', cli_parsers_1.parseBelongsTo)
+    .option('--has-many <associations>', 'Comma-separated hasMany associations in format name:model:via[:dominant]', cli_parsers_1.parseHasMany)
+    .action(async (name, options) => {
+    try {
+        const globalOptions = program.opts();
+        const paths = (0, paths_1.resolvePaths)(globalOptions);
+        const { ModelGenerator } = require('./generators/model');
+        const generator = new ModelGenerator({
+            name,
+            identity: options.identity,
+            attributes: options.attrs,
+            associations: [...(options.belongsTo || []), ...(options.hasMany || [])],
+            dryRun: globalOptions.dryRun,
+            root: paths.root,
+            paths,
+        });
+        console.log(`\n🛠️  Generating Waterline model: ${name}...\n`);
+        await generator.generate();
+        console.log('\n✅ Done!\n');
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/commands/form-config.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+export declare function registerMigrateFormConfigCommand(program: Command): void;
+export declare function registerMigrateDataClassificationCommand(program: Command): void;
+export declare function registerClientFormConfigCommand(program: Command): void;
+export declare function registerQuestionTreeDiagramCommand(program: Command): void;

package/dist/commands/form-config.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMigrateFormConfigCommand = registerMigrateFormConfigCommand;
+exports.registerMigrateDataClassificationCommand = registerMigrateDataClassificationCommand;
+exports.registerClientFormConfigCommand = registerClientFormConfigCommand;
+exports.registerQuestionTreeDiagramCommand = registerQuestionTreeDiagramCommand;
+const fs_1 = __importDefault(require("fs"));
+const path = __importStar(require("path"));
+const redbox_core_1 = require("@researchdatabox/redbox-core");
+const migrationLogger = {
+    silly: (...args) => console.debug(...args),
+    verbose: (...args) => console.debug(...args),
+    trace: (...args) => console.debug(...args),
+    debug: (...args) => console.debug(...args),
+    log: (...args) => console.log(...args),
+    info: (...args) => console.info(...args),
+    warn: (...args) => console.warn(...args),
+    error: (...args) => console.error(...args),
+    crit: (...args) => console.error(...args),
+    fatal: (...args) => console.error(...args),
+    silent: () => undefined,
+    blank: () => undefined,
+};
+function registerMigrateFormConfigCommand(program) {
+    program
+        .command('migrate-form-config')
+        .description('Migrate a legacy v4 JS form config file to the v5 TS form framework format')
+        .requiredOption('-i, --input <path>', 'Path to the legacy v4 form config JS file')
+        .requiredOption('-o, --output <path>', 'Path to write the migrated v5 TypeScript config file')
+        .option('--format <name>', "The output format, either 'esm' or 'cjs'")
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            const outputFormat = options.format || "esm";
+            console.log(`\n🛠️  Migrating form config to ${outputFormat} format: ${inputPath} -> ${outputPath}\n`);
+            const migrateVisitor = new redbox_core_1.MigrationV4ToV5FormConfigVisitor(migrationLogger);
+            const migrated = await (0, redbox_core_1.migrateFormConfigFile)(migrateVisitor, inputPath, outputFormat);
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Migration completed; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, migrated.tsContent, 'utf8');
+                console.log(`✅ Wrote migrated form config: ${outputPath}`);
+            }
+            await (0, redbox_core_1.migrateFormConfigVerify)(migrated.migrated, migrationLogger);
+            console.log('\n✅ Done!\n');
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function registerMigrateDataClassificationCommand(program) {
+    program
+        .command('migrate-data-classification')
+        .description('Migrate a legacy v4 JS data classification definition file to the v5 TS form framework format')
+        .requiredOption('-i, --input <path>', 'Path to the legacy v4 JS data classification definition file')
+        .requiredOption('-o, --output <path>', 'Path to write the migrated v5 TypeScript question tree config file')
+        .option('--format <name>', "The output format, either 'esm' or 'cjs'")
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            const outputFormat = options.format || 'esm';
+            console.log(`\n🛠️  Migrating data classification to question tree to ${outputFormat} format: ${inputPath} -> ${outputPath}\n`);
+            const migrateVisitor = new redbox_core_1.MigrationV4ToV5FormConfigVisitor(migrationLogger);
+            const migrated = (0, redbox_core_1.migrateDataClassification)(migrateVisitor, inputPath, outputFormat);
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Migration completed; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, migrated.tsContent, 'utf8');
+                console.log(`✅ Wrote migrated question tree config: ${outputPath}`);
+            }
+            await (0, redbox_core_1.migrateFormConfigVerify)(migrated.formConfig, migrationLogger);
+            console.log('\n✅ Done!\n');
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function registerClientFormConfigCommand(program) {
+    program
+        .command('client-form-config')
+        .description('Process a form config to produce the client form config')
+        .requiredOption('-i, --input <path>', 'Path to read the server-side form config TypeScript file')
+        .requiredOption('-o, --output <path>', 'Path to write the client-side form config TypeScript file')
+        .option('--formMode <name>', "The form mode, either 'edit' or 'view'")
+        .option('--userRoles <name...>', "The user roles, zero or more of 'Admin', 'Librarians', 'Researcher', 'Guest'")
+        .option('-r, --record <path>', "Path to read the data record file")
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            const formMode = options.formMode ?? null;
+            const userRoles = options.userRoles ?? null;
+            const record = options.record ? require(path.resolve(options.record)) : null;
+            console.log(`\n🛠️  Building client form config from server form config: ${inputPath} -> ${outputPath}\n`);
+            const serverFormConfig = require(inputPath).default;
+            const clientFormConfig = await (0, redbox_core_1.createClientFormConfig)(serverFormConfig, migrationLogger, formMode, userRoles, undefined, record);
+            const tsContent = `import { FormConfigFrame } from '@researchdatabox/sails-ng-common';
+const clientFormConfig: FormConfigFrame = ${JSON.stringify(clientFormConfig, null, 2)};
+export default clientFormConfig;`;
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Client form config built from server form config; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, tsContent, 'utf8');
+                console.log(`✅ Wrote client form config: ${outputPath}`);
+            }
+            await (0, redbox_core_1.migrateFormConfigVerify)(clientFormConfig, migrationLogger);
+            console.log('\n✅ Done!\n');
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}
+function registerQuestionTreeDiagramCommand(program) {
+    program
+        .command('question-tree-diagram')
+        .description('Convert a question tree config to a mermaid diagram text file')
+        .requiredOption('-i, --input <path>', 'Path to read the question tree form config TypeScript file')
+        .requiredOption('-o, --output <path>', 'Path to write the diagram text file')
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const inputPath = path.resolve(options.input);
+            const outputPath = path.resolve(options.output);
+            console.log(`\n🛠️  Creating diagram from form config: ${inputPath} -> ${outputPath}\n`);
+            const componentConfig = require(inputPath);
+            const diagram = await (0, redbox_core_1.createQuestionTreeDiagram)(componentConfig, migrationLogger);
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Built diagram from form config; no file written.');
+            }
+            else {
+                fs_1.default.mkdirSync(path.dirname(outputPath), { recursive: true });
+                fs_1.default.writeFileSync(outputPath, diagram, 'utf8');
+                console.log(`✅ Wrote diagram text file: ${outputPath}`);
+            }
+        }
+        catch (error) {
+            console.error(`\n❌ Error: `, error);
+            process.exit(1);
+        }
+    });
+}

package/dist/completion/index.d.ts

@@ -0,0 +1 @@
+export declare function generateCompletionScript(shell: string): string;