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

package/dist/commands/form-config.js

@@ -0,0 +1,404 @@
+"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;
+exports.registerMigrateFigshareConfigCommand = registerMigrateFigshareConfigCommand;
+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);
+        }
+    });
+}
+function collectLegacyTemplates(value, pathPrefix = '') {
+    if (typeof value === 'string') {
+        return value.includes('<%') ? [pathPrefix] : [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((entry, index) => collectLegacyTemplates(entry, `${pathPrefix}[${index}]`));
+    }
+    if (value && typeof value === 'object') {
+        return Object.entries(value).flatMap(([key, entry]) => collectLegacyTemplates(entry, pathPrefix ? `${pathPrefix}.${key}` : key));
+    }
+    return [];
+}
+function loadLegacyModule(modulePath) {
+    const resolvedPath = path.resolve(modulePath);
+    const loaded = require(resolvedPath);
+    if (loaded == null || typeof loaded !== 'object') {
+        throw new Error(`Legacy config module '${resolvedPath}' did not export an object`);
+    }
+    return loaded;
+}
+function pickLegacyExport(moduleExports, exportName) {
+    const named = moduleExports[exportName];
+    if (named != null && typeof named === 'object') {
+        return named;
+    }
+    return moduleExports;
+}
+function toNumericStatusCodes(value) {
+    if (!Array.isArray(value)) {
+        return [408, 429, 500, 502, 503, 504];
+    }
+    return value
+        .map((entry) => Number(entry))
+        .filter((entry) => Number.isFinite(entry));
+}
+function createMigratedFigsharePublishingConfig(brand, figshareApi, figshareApiEnv = {}, figshareForMapping = {}) {
+    const overrideArtifacts = figshareApiEnv.overrideArtifacts ?? {};
+    const mapping = {
+        ...(figshareApi.mapping ?? {}),
+        ...(overrideArtifacts.mapping ?? {})
+    };
+    const resolvedBaseUrl = String(overrideArtifacts.baseURL ?? figshareApi.baseURL ?? '');
+    const resolvedFrontEndUrl = String(overrideArtifacts.frontEndURL ?? figshareApi.frontEndURL ?? '');
+    const resolvedToken = String(overrideArtifacts.APIToken ?? figshareApi.APIToken ?? '');
+    return {
+        enabled: Boolean(resolvedToken && resolvedBaseUrl && resolvedFrontEndUrl),
+        connection: {
+            baseUrl: resolvedBaseUrl,
+            frontEndUrl: resolvedFrontEndUrl,
+            token: resolvedToken,
+            timeoutMs: 30000,
+            operationTimeouts: {
+                metadataMs: 30000,
+                uploadInitMs: 30000,
+                uploadPartMs: 120000,
+                publishMs: 60000
+            },
+            retry: {
+                maxAttempts: Number(figshareApi.retry?.maxAttempts ?? 3),
+                baseDelayMs: Number(figshareApi.retry?.baseDelayMs ?? 500),
+                maxDelayMs: Number(figshareApi.retry?.maxDelayMs ?? 4000),
+                retryOnStatusCodes: toNumericStatusCodes(figshareApi.retry?.retryOnStatusCodes),
+                retryOnMethods: ['get', 'put', 'delete']
+            }
+        },
+        article: {
+            itemType: mapping.figshareItemType ?? 'dataset',
+            groupId: mapping.figshareItemGroupId,
+            publishMode: mapping.figshareNeedsPublishAfterFileUpload ? 'afterUploadsComplete' : 'immediate',
+            republishOnMetadataChange: true,
+            republishOnAssetChange: true
+        },
+        record: {
+            articleIdPath: mapping.recordFigArticleId ?? 'metadata.figshare_article_id',
+            articleUrlPaths: Array.isArray(mapping.recordFigArticleURL) ? mapping.recordFigArticleURL : [mapping.recordFigArticleURL ?? 'metadata.figshare_article_location'],
+            dataLocationsPath: mapping.recordDataLocations ?? 'metadata.dataLocations',
+            statusPath: 'metadata.figshareStatus',
+            errorPath: 'metadata.figshareError',
+            syncStatePath: 'metadata.figshareSyncState',
+            allFilesUploadedPath: typeof mapping.recordAllFilesUploaded === 'string' ? mapping.recordAllFilesUploaded : ''
+        },
+        selection: {
+            attachmentMode: mapping.figshareOnlyPublishSelectedAttachmentFiles ? 'selectedOnly' : 'all',
+            urlMode: mapping.figshareOnlyPublishSelectedLocationURLs ? 'selectedOnly' : 'all',
+            selectedFlagPath: 'selected'
+        },
+        authors: {
+            source: 'defaultRedboxContributors',
+            uniqueBy: mapping.recordAuthorUniqueBy ?? 'email',
+            externalNameField: mapping.recordAuthorExternalName ?? 'text_full_name',
+            maxInlineAuthors: 50,
+            contributorPaths: ['metadata.contributor_ci', 'metadata.contributors'],
+            lookup: []
+        },
+        metadata: {
+            title: { kind: 'path', path: 'metadata.title' },
+            description: { kind: 'path', path: 'metadata.description' },
+            keywords: { kind: 'path', path: 'metadata.finalKeywords', defaultValue: [] },
+            funding: { kind: 'path', path: 'metadata.funder' },
+            license: { source: { kind: 'path', path: mapping.recordLicensePath ?? 'metadata.license' }, matchBy: 'urlContains', required: true },
+            categories: { source: { kind: 'path', path: mapping.recordCategoryPath ?? 'metadata.forCodes', defaultValue: [] }, mappingStrategy: 'for2020Mapping' },
+            customFields: []
+        },
+        categories: {
+            strategy: 'for2020Mapping',
+            mappingTable: ((figshareForMapping.FORMapping ?? []).map((entry) => ({
+                sourceCode: String(entry.redboxCode ?? entry.sourceCode ?? ''),
+                figshareCategoryId: Number(entry.figshareCategoryId ?? entry.figCode ?? 0)
+            }))).filter((entry) => entry.sourceCode !== ''),
+            allowUnmapped: false
+        },
+        assets: {
+            enableHostedFiles: true,
+            enableLinkFiles: true,
+            dedupeStrategy: 'sourceId',
+            staging: {
+                tempDir: String(figshareApi.attachmentsFigshareTempDir ?? ''),
+                cleanupPolicy: 'deleteAfterSuccess',
+                diskSpaceThresholdBytes: 1073741824
+            }
+        },
+        embargo: {
+            mode: 'recordDriven',
+            forceSync: Boolean(mapping.figshareForceEmbargoUpdateAlways),
+            accessRights: {
+                accessRights: { kind: 'path', path: 'metadata.accessRights' },
+                fullEmbargoUntil: { kind: 'path', path: 'metadata.embargoUntil' },
+                fileEmbargoUntil: { kind: 'path', path: 'metadata.embargoUntil' },
+                reason: { kind: 'path', path: 'metadata.embargoReason' }
+            }
+        },
+        queue: {
+            publishAfterUploadDelay: typeof mapping.schedulePublishAfterUploadJob === 'string' ? mapping.schedulePublishAfterUploadJob : 'in 2 minutes',
+            uploadedFilesCleanupDelay: typeof mapping.scheduleUploadedFilesCleanupJob === 'string' ? mapping.scheduleUploadedFilesCleanupJob : 'in 5 minutes'
+        },
+        workflow: {
+            transitionRules: [],
+            transitionJob: {
+                enabled: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.enabled ?? 'false') === 'true',
+                namedQuery: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.namedQuery ?? ''),
+                targetStep: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.targetStep ?? ''),
+                paramMap: mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.paramMap ?? {},
+                figshareTargetFieldKey: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.figshareTargetFieldKey ?? ''),
+                figshareTargetFieldValue: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.figshareTargetFieldValue ?? ''),
+                username: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.username ?? ''),
+                userType: String(mapping.figshareScheduledTransitionRecordWorkflowFromArticlePropertiesJob?.userType ?? '')
+            }
+        },
+        testing: {
+            mode: figshareApi.testMode ? 'fixture' : 'live'
+        },
+        writeBack: {
+            articleId: 'metadata.figshare_article_id',
+            articleUrls: ['metadata.figshare_article_location'],
+            extraFields: []
+        },
+        migrationReport: {
+            brand,
+            unsupportedLegacyTemplates: collectLegacyTemplates(mapping)
+        }
+    };
+}
+function registerMigrateFigshareConfigCommand(program) {
+    program
+        .command('migrate-figshare-config')
+        .description('Migrate legacy Figshare config into figsharePublishing AppConfig JSON files')
+        .requiredOption('--figshare-api <path>', 'Path to the legacy figshareAPI config module')
+        .option('--figshare-api-env <path>', 'Path to the legacy figshareAPIEnv config module')
+        .option('--figshare-for-mapping <path>', 'Path to the legacy figshareReDBoxFORMapping config module')
+        .requiredOption('-o, --output <path>', 'Directory to write migrated figsharePublishing JSON files')
+        .option('-b, --brands <brands...>', 'Brands to generate config for', ['default'])
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const outputDir = path.resolve(options.output);
+            const brands = options.brands;
+            const figshareApi = pickLegacyExport(loadLegacyModule(options.figshareApi), 'figshareAPI');
+            const figshareApiEnv = options.figshareApiEnv
+                ? pickLegacyExport(loadLegacyModule(options.figshareApiEnv), 'figshareAPIEnv')
+                : {};
+            const figshareForMapping = options.figshareForMapping
+                ? pickLegacyExport(loadLegacyModule(options.figshareForMapping), 'figshareReDBoxFORMapping')
+                : {};
+            if (!globalOptions.dryRun) {
+                fs_1.default.mkdirSync(outputDir, { recursive: true });
+            }
+            const report = brands.map((brand) => {
+                const migrated = createMigratedFigsharePublishingConfig(brand, figshareApi, figshareApiEnv, figshareForMapping);
+                const outputPath = path.join(outputDir, `${brand}.figsharePublishing.json`);
+                if (!globalOptions.dryRun) {
+                    fs_1.default.writeFileSync(outputPath, JSON.stringify(migrated, null, 2) + '\n', 'utf8');
+                }
+                return {
+                    brand,
+                    outputPath,
+                    unsupportedLegacyTemplates: migrated.migrationReport.unsupportedLegacyTemplates
+                };
+            });
+            if (globalOptions.dryRun) {
+                console.log('[dry-run] Migration report generated; no files written.');
+            }
+            console.log(JSON.stringify(report, null, 2));
+        }
+        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;

package/dist/completion/index.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCompletionScript = generateCompletionScript;
+function getCompletionSpec() {
+    const globalOptions = ['--root', '--core-types-root', '--angular-root', '--dry-run', '-h', '--help', '-V', '--version'];
+    const topLevelCommands = ['init', 'check', 'migrate-hook-dependencies', 'generate', 'g', 'install-skills', 'skills', 'migrate-form-config', 'completion', 'help'];
+    const generateCommands = ['controller', 'service', 'method', 'angular-app', 'angular-service', 'form-component', 'form-field', 'migration', 'model'];
+    const commandOptions = {
+        'migrate-form-config': ['-i', '--input', '-o', '--output'],
+        'check': [],
+        'completion': [],
+        'init': [],
+        'install-skills': [],
+        'migrate-hook-dependencies': [],
+        'skills': [],
+        'generate controller': ['--actions', '--webservice', '--class-name', '--route', '--routes', '--nav', '--lang', '--auth'],
+        'generate service': ['--methods'],
+        'generate method': ['--file', '--method', '--route', '--http', '--auth', '--nav', '--lang'],
+        'generate angular-app': ['--ejs-view', '--auth'],
+        'generate angular-service': ['--app', '--methods'],
+        'generate form-component': ['--app', '--with-service'],
+        'generate form-field': ['--type'],
+        'generate migration': [],
+        'generate model': ['--identity', '--attrs', '--belongs-to', '--has-many']
+    };
+    const fileValueOptions = ['--root', '--core-types-root', '--angular-root', '--input', '--output', '--file'];
+    return { globalOptions, topLevelCommands, generateCommands, commandOptions, fileValueOptions };
+}
+function generateBashCompletion() {
+    const spec = getCompletionSpec();
+    const top = spec.topLevelCommands.join(' ');
+    const generateSubs = spec.generateCommands.join(' ');
+    const globalOpts = spec.globalOptions.join(' ');
+    const fileOpts = spec.fileValueOptions.join(' ');
+    const commandOptionEntries = Object.entries(spec.commandOptions)
+        .map(([key, value]) => `"${key}") opts="${value.join(' ')}";;`)
+        .join('\n      ');
+    return `# bash completion for redbox-dev-tools
+_redbox_dev_tools_completion() {
+  local cur prev words cword
+  _init_completion || return
+
+  local top_commands="${top}"
+  local generate_subcommands="${generateSubs}"
+  local global_opts="${globalOpts}"
+  local file_value_opts="${fileOpts}"
+
+  case "$prev" in
+    $file_value_opts)
+      COMPREPLY=($(compgen -f -- "$cur"))
+      return
+      ;;
+  esac
+
+  if [[ $cword -le 1 ]]; then
+    COMPREPLY=($(compgen -W "$top_commands $global_opts" -- "$cur"))
+    return
+  fi
+
+  if [[ "\${words[1]}" == "generate" || "\${words[1]}" == "g" ]]; then
+    if [[ $cword -eq 2 ]]; then
+      COMPREPLY=($(compgen -W "$generate_subcommands" -- "$cur"))
+      return
+    fi
+    local key="generate \${words[2]}"
+    local opts=""
+    case "$key" in
+      ${commandOptionEntries}
+      *) opts="";;
+    esac
+    COMPREPLY=($(compgen -W "$opts $global_opts" -- "$cur"))
+    return
+  fi
+
+  local opts=""
+  case "\${words[1]}" in
+    "migrate-form-config") opts="-i --input -o --output" ;;
+    "check") opts="" ;;
+    "completion") opts="" ;;
+    "init") opts="" ;;
+    "install-skills") opts="" ;;
+    "migrate-hook-dependencies") opts="" ;;
+    "skills") opts="" ;;
+    *) opts="" ;;
+  esac
+
+  COMPREPLY=($(compgen -W "$opts $global_opts" -- "$cur"))
+}
+
+complete -F _redbox_dev_tools_completion redbox-dev-tools
+`;
+}
+function generateZshCompletion() {
+    const bashScript = generateBashCompletion();
+    return `#compdef redbox-dev-tools
+autoload -U +X bashcompinit && bashcompinit
+${bashScript}`;
+}
+function generateFishCompletion() {
+    const spec = getCompletionSpec();
+    const lines = [
+        '# fish completion for redbox-dev-tools',
+        'set -l __rbhk_cmd redbox-dev-tools',
+        'complete -c $__rbhk_cmd -f'
+    ];
+    for (const cmd of spec.topLevelCommands) {
+        lines.push(`complete -c $__rbhk_cmd -n "__fish_use_subcommand" -a "${cmd}"`);
+    }
+    for (const option of spec.globalOptions) {
+        if (option.startsWith('--')) {
+            const name = option.replace(/^--/, '');
+            const requiresValue = ['root', 'core-types-root', 'angular-root'].includes(name);
+            lines.push(`complete -c $__rbhk_cmd -l ${name}${requiresValue ? ' -r' : ''}`);
+        }
+    }
+    for (const sub of spec.generateCommands) {
+        lines.push(`complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate g; and __fish_use_subcommand" -a "${sub}"`);
+    }
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from migrate-form-config" -s i -l input -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from migrate-form-config" -s o -l output -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from completion" -a "bash zsh fish powershell pwsh"');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l actions -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l webservice');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l class-name -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l route -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l routes -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l nav -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l lang -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from controller" -l auth -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from service" -l methods -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l file -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l method -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l route -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l http -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l auth -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l nav -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from method" -l lang -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-app" -l ejs-view -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-app" -l auth -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-service" -l app -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from angular-service" -l methods -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from form-component" -l app -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from form-component" -l with-service');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from form-field" -l type -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l identity -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l attrs -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l belongs-to -r');
+    lines.push('complete -c $__rbhk_cmd -n "__fish_seen_subcommand_from generate; and __fish_seen_subcommand_from model" -l has-many -r');
+    return `${lines.join('\n')}\n`;
+}
+function generatePowerShellCompletion() {
+    return `# PowerShell completion for redbox-dev-tools
+Register-ArgumentCompleter -Native -CommandName redbox-dev-tools -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $tokens = $commandAst.CommandElements | ForEach-Object { $_.Extent.Text }
+  $global = @('--root','--core-types-root','--angular-root','--dry-run','-h','--help','-V','--version')
+  $top = @('init','check','migrate-hook-dependencies','generate','g','install-skills','skills','migrate-form-config','completion','help')
+  $generateSub = @('controller','service','method','angular-app','angular-service','form-component','form-field','migration','model')
+
+  if ($tokens.Count -le 2) {
+    @($top + $global) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+    }
+    return
+  }
+
+  if ($tokens[1] -eq 'generate' -or $tokens[1] -eq 'g') {
+    if ($tokens.Count -le 3) {
+      $generateSub | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
+      }
+      return
+    }
+    $sub = $tokens[2]
+    $opts = switch ($sub) {
+      'controller' { @('--actions','--webservice','--class-name','--route','--routes','--nav','--lang','--auth') }
+      'service' { @('--methods') }
+      'method' { @('--file','--method','--route','--http','--auth','--nav','--lang') }
+      'angular-app' { @('--ejs-view','--auth') }
+      'angular-service' { @('--app','--methods') }
+      'form-component' { @('--app','--with-service') }
+      'form-field' { @('--type') }
+      'model' { @('--identity','--attrs','--belongs-to','--has-many') }
+      default { @() }
+    }
+    @($opts + $global) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+      [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+    }
+    return
+  }
+
+  $opts = switch ($tokens[1]) {
+    'migrate-form-config' { @('-i','--input','-o','--output') }
+    'completion' { @('bash','zsh','fish','powershell','pwsh') }
+    default { @() }
+  }
+
+  @($opts + $global) | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
+    [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterName', $_)
+  }
+}
+`;
+}
+function generateCompletionScript(shell) {
+    switch (shell) {
+        case 'bash':
+            return generateBashCompletion();
+        case 'zsh':
+            return generateZshCompletion();
+        case 'fish':
+            return generateFishCompletion();
+        case 'powershell':
+        case 'pwsh':
+            return generatePowerShellCompletion();
+        default:
+            throw new Error(`Unsupported shell '${shell}'. Expected one of: bash, zsh, fish, powershell`);
+    }
+}

package/dist/generators/add-method.d.ts

@@ -0,0 +1,27 @@
+import { Generator, GeneratorOptions } from '../utils/generator';
+import { RedboxPaths } from '../utils/paths';
+import { NavigationMapping, LanguageDefaultEntry } from '../utils/config-helper';
+export interface AddMethodGeneratorOptions extends GeneratorOptions {
+    file: string;
+    method: string;
+    route?: string;
+    http?: string;
+    auth?: string[];
+    navigation?: NavigationMapping[];
+    languageDefaults?: LanguageDefaultEntry[];
+    paths: RedboxPaths;
+}
+export declare class AddMethodGenerator extends Generator {
+    private filePath;
+    private method;
+    private route?;
+    private http?;
+    private auth?;
+    private navigation;
+    private languageDefaults;
+    private paths;
+    private project;
+    constructor(options: AddMethodGeneratorOptions);
+    generate(): Promise<void>;
+    private updateClass;
+}