@researchdatabox/redbox-dev-tools 0.0.1 → 5.0.0-RC1

package/dist/commands/sync-translation.js

@@ -0,0 +1,348 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSyncTranslationCommand = registerSyncTranslationCommand;
+const commander_1 = require("commander");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const contentFormats = ["plain", "html"];
+/**
+ * Use a type predicate to narrow a string to a content format.
+ * @param value The value to check.
+ */
+function isContentFormat(value) {
+    return contentFormats.some(contentFormat => contentFormat === value);
+}
+/**
+ * Build a path from a base path and additional parts.
+ * @param basePath The base path.
+ * @param parts The additional path parts.
+ */
+function buildPath(basePath, ...parts) {
+    if (!basePath.trim()) {
+        throw new Error(`Invalid base path ${basePath}`);
+    }
+    const basePathResolved = node_path_1.default.resolve(basePath);
+    const resolved = node_path_1.default.resolve(...[basePathResolved, ...parts]);
+    // Ensure resolved path is inside basePath
+    if (!resolved.startsWith(basePathResolved + node_path_1.default.sep) && resolved !== basePathResolved) {
+        throw new Error(`Invalid path ${resolved}`);
+    }
+    return resolved;
+}
+/**
+ * Get the last non-empty string.
+ * @param value The strings.
+ */
+function lastNonEmptyString(...value) {
+    for (let index = (value.length - 1); index >= 0; index--) {
+        const item = value[index];
+        if (typeof item === 'string' && item.length > 0) {
+            return item;
+        }
+    }
+    return undefined;
+}
+/**
+ * Read the translation json files.
+ * @param filesPath The path to the top directory containing the meta.json file.
+ */
+async function readTranslationFiles(filesPath) {
+    // Read files
+    const metaPath = buildPath(filesPath, 'meta.json');
+    console.log(`Load translation meta file ${metaPath}`);
+    const metaData = JSON.parse(await promises_1.default.readFile(metaPath, { encoding: 'utf8' }));
+    const localeNames = (await promises_1.default.readdir(filesPath, { withFileTypes: true }))
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    const localeTranslationData = [];
+    for (const locale of localeNames) {
+        let p;
+        try {
+            p = buildPath(filesPath, locale, 'translation.json');
+            const translationStat = await promises_1.default.stat(p);
+            if (!translationStat.isFile()) {
+                continue;
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+                // Nested folders such as language-defaults/demo are documentation
+                // or sample data, not locale roots.
+                continue;
+            }
+            throw err;
+        }
+        if (!p) {
+            continue;
+        }
+        const data = JSON.parse(await promises_1.default.readFile(p, { encoding: 'utf8' }));
+        console.log(`Load translation locale file ${p}`);
+        localeTranslationData.push({ locale, source: p, data });
+    }
+    return {
+        meta: {
+            source: metaPath,
+            data: metaData,
+        },
+        locales: localeTranslationData,
+    };
+}
+/**
+ * Write updated translation json files.
+ * @param opts The options.
+ * @param opts.meta The meta details.
+ * @param opts.locales The translation locale data.
+ * @param opts.dryRun Whether this is a dry run.
+ * @param opts.writePath The top-level path to write the output.
+ */
+async function writeTranslationFiles(opts) {
+    const metaPath = buildPath(opts?.writePath, 'meta.json');
+    if (opts.dryRun) {
+        console.log(`[dry-run] Not writing updated meta to ${metaPath}`);
+    }
+    else {
+        // Write merged meta back to file
+        console.log(`Writing updated meta to ${metaPath}`);
+        await promises_1.default.mkdir(node_path_1.default.dirname(metaPath), { recursive: true });
+        await promises_1.default.writeFile(metaPath, JSON.stringify(opts.meta, null, 2));
+    }
+    // Write translation files
+    for (const [locale, data] of Object.entries(opts.locales)) {
+        const translationPath = buildPath(opts?.writePath, locale, 'translation.json');
+        if (opts.dryRun) {
+            console.log(`[dry-run] Not writing updated translation data to ${translationPath}`);
+        }
+        else {
+            console.log(`Writing updated translation data to ${translationPath}`);
+            await promises_1.default.mkdir(node_path_1.default.dirname(translationPath), { recursive: true });
+            await promises_1.default.writeFile(translationPath, JSON.stringify(data, null, 2));
+        }
+    }
+}
+/**
+ * Read translation data from ReDBox API.
+ * @param apiBaseUrl The base url for the API calls.
+ */
+async function readTranslationApi(apiBaseUrl) {
+    if (!apiBaseUrl.includes('://')) {
+        throw new Error(`Api base url is not a valid url '${apiBaseUrl}'`);
+    }
+    if (!apiBaseUrl.endsWith('/')) {
+        apiBaseUrl += '/';
+    }
+    const translationUrl = new URL('default/rdmp/locales/__locale__/translation.json', apiBaseUrl);
+    const entriesUrl = new URL('default/rdmp/app/i18n/entries', apiBaseUrl);
+    console.log(`Load translation entries url ${entriesUrl}`);
+    const entriesResponse = await fetch(entriesUrl, { signal: AbortSignal.timeout(5000) });
+    if (!entriesResponse.ok) {
+        throw new Error(`Could not fetch translation entries: status ${entriesResponse.status} body ${await entriesResponse.text()}`);
+    }
+    const entriesData = await entriesResponse.json();
+    const metaData = Object.create(null);
+    const localeTranslationData = [];
+    const localeNames = Array.from(new Set(entriesData.map(e => e.locale).filter(l => typeof l === 'string'))).sort();
+    for (const localeName of localeNames) {
+        if (!localeName || !localeName.trim() || localeName.includes('.') || localeName.includes('/')) {
+            console.warn(`Ignoring invalid locale name '${localeName}'.`);
+            continue;
+        }
+        const translationLocaleUrl = new URL(translationUrl.toString().replace('/__locale__/', `/${encodeURIComponent(localeName)}/`));
+        console.log(`Load translation locale url ${translationLocaleUrl}`);
+        const translationResponse = await fetch(translationLocaleUrl, { signal: AbortSignal.timeout(5000) });
+        if (!translationResponse.ok) {
+            throw new Error(`Could not fetch translation locale: status ${translationResponse.status} body ${await translationResponse.text()}`);
+        }
+        localeTranslationData.push({
+            locale: localeName,
+            source: translationLocaleUrl.toString(),
+            data: await translationResponse.json()
+        });
+    }
+    for (const entryData of entriesData) {
+        if (!entryData.key) {
+            continue;
+        }
+        if (!(entryData.key in metaData)) {
+            metaData[entryData.key] = Object.create(null);
+        }
+        if (entryData.category) {
+            metaData[entryData.key].category = entryData.category;
+        }
+        if (entryData.contentFormat) {
+            metaData[entryData.key].contentFormat = entryData.contentFormat;
+        }
+        if (entryData.description) {
+            metaData[entryData.key].description = entryData.description;
+        }
+    }
+    return {
+        meta: {
+            source: entriesUrl.toString(),
+            data: metaData,
+        },
+        locales: localeTranslationData,
+    };
+}
+/**
+ * Merge two or more meta entries.
+ * @param opts The merge options.
+ * @param opts.key The translation key.
+ * @param opts.value The translation value.
+ * @param opts.items The meta entries.
+ * @param opts.guessContentFormat Whether to guess the content format from the translation value.
+ */
+function mergeMetaItems(opts) {
+    // content format
+    const contentFormatRaw = lastNonEmptyString(...opts.items?.map(i => i?.contentFormat));
+    let contentFormat = isContentFormat(contentFormatRaw) ? contentFormatRaw : undefined;
+    const isHtml = opts.guessContentFormat === true &&
+        opts.value !== undefined &&
+        contentFormat === undefined &&
+        (typeof opts.value === 'string' && (opts.value?.includes('<') &&
+            opts.value?.includes('</') &&
+            opts.value?.includes('>')));
+    if (isHtml) {
+        contentFormat = "html";
+    }
+    // description
+    const description = lastNonEmptyString(...[
+        opts?.key === undefined ? "" : `Translation for ${opts.key}`,
+        ...opts.items?.map(i => i?.description),
+    ]);
+    // category
+    const keySplit = typeof opts.key === 'string' ? opts.key.split(/[_\-:.@]+/).filter(i => !!i) : [];
+    const category = lastNonEmptyString(...[
+        keySplit.length > 0 ? keySplit[0] : undefined,
+        ...opts.items?.map(i => i?.category),
+    ]);
+    const result = Object.create(null);
+    result.category = category;
+    result.description = description;
+    result.contentFormat = contentFormat;
+    return result;
+}
+function registerSyncTranslationCommand(program) {
+    const sourcesCollected = [];
+    program
+        .command('sync-translation')
+        .description('Read translations from API and/or json files, and write to language translation files.')
+        .option('-l, --language-defaults <path>', 'Path to read the language-defaults directory containing locales and meta json files. Can be provided multiple times.', (value, previous) => {
+        previous.push({ type: 'language-defaults', value });
+        return previous;
+    }, sourcesCollected)
+        .option('-a, --api-base <url>', 'Base url for the API to read translation data. Can be provided multiple times.', (value, previous) => {
+        previous.push({ type: 'api-base', value });
+        return previous;
+    }, sourcesCollected)
+        .requiredOption('-o, --output <path>', 'Path to the output directory or file.')
+        .addOption(new commander_1.Option('-f, --format <format>', 'The output format.')
+        .choices(['language-defaults'])
+        .default('language-defaults'))
+        .action(async (options) => {
+        try {
+            const globalOptions = program.opts();
+            const outputPath = options.output;
+            const outputFormat = options.format;
+            const sources = sourcesCollected.splice(0);
+            if (sources.length === 0) {
+                throw new Error(`Must provide at least one of language-defaults path or api-base url.`);
+            }
+            // Get existing translation data
+            const sourceMeta = [];
+            const sourceTranslations = [];
+            // Precedence order: later items overwrite earlier items.
+            // Populate source meta and translations in order provided in command line.
+            for (const { type, value } of sources) {
+                if (type === 'language-defaults') {
+                    const { meta, locales } = await readTranslationFiles(value);
+                    sourceMeta.push(meta);
+                    sourceTranslations.push(...locales);
+                }
+                else if (type === 'api-base') {
+                    const { meta, locales } = await readTranslationApi(value);
+                    sourceMeta.push(meta);
+                    sourceTranslations.push(...locales);
+                }
+                else {
+                    throw new Error(`Unknown source type '${type}'.`);
+                }
+            }
+            // The keys for locales are the source of truth,
+            // so any keys in meta that are not in any locale data will be dropped.
+            const keys = new Set(sourceTranslations.flatMap(i => Object.keys(i.data)));
+            // Cache translations by locale so each source is grouped only once.
+            const sourceTranslationsByLocale = new Map();
+            for (const sourceTranslation of sourceTranslations) {
+                const localeTranslations = sourceTranslationsByLocale.get(sourceTranslation.locale) ?? [];
+                localeTranslations.push(sourceTranslation);
+                sourceTranslationsByLocale.set(sourceTranslation.locale, localeTranslations);
+            }
+            // The unique locale names.
+            const localeNames = Array.from(sourceTranslationsByLocale.keys()).sort();
+            // Gather translation and meta entries.
+            const meta = Object.create(null);
+            const locales = Object.create(null);
+            for (const key of keys) {
+                if (!key) {
+                    continue;
+                }
+                for (const localeName of localeNames) {
+                    if (!localeName) {
+                        continue;
+                    }
+                    if (!(localeName in locales)) {
+                        locales[localeName] = Object.create(null);
+                    }
+                    const localeTranslationData = sourceTranslationsByLocale.get(localeName) ?? [];
+                    // Translation value for a locale key.
+                    const values = localeTranslationData
+                        .map(i => i.data?.[key])
+                        .filter(i => typeof i === 'string')
+                        .filter(i => i?.trim().length > 0);
+                    if (new Set(values).size > 1) {
+                        console.warn(`Translation '${localeName}' key '${key}' has more than one value: ${JSON.stringify(values)}`);
+                    }
+                    const valuesNonString = localeTranslationData
+                        .map(i => i.data?.[key])
+                        .filter(i => typeof i !== 'string' && i !== undefined);
+                    if (valuesNonString.length > 0) {
+                        console.warn(`Translation '${localeName}' key '${key}' has non-string values that were ignored:`, valuesNonString);
+                    }
+                    const value = lastNonEmptyString(...values);
+                    locales[localeName][key] = value ?? "";
+                }
+                // Use the first populated locale in sorted order when inferring meta.
+                const valueForMeta = localeNames
+                    .map(localeName => locales[localeName]?.[key])
+                    .find(value => typeof value === 'string' && value.trim().length > 0);
+                meta[key] = mergeMetaItems({
+                    key,
+                    value: valueForMeta,
+                    items: sourceMeta.map(i => i.data?.[key]),
+                    guessContentFormat: true,
+                }) ?? Object.create(null);
+            }
+            // Write output
+            if (outputFormat === "language-defaults") {
+                await writeTranslationFiles({
+                    meta,
+                    locales,
+                    writePath: outputPath,
+                    dryRun: globalOptions.dryRun,
+                });
+            }
+            else {
+                throw new Error(`Unknown output format '${outputFormat}'`);
+            }
+            console.log(`\n🛠️  Ran sync-translation`);
+            console.log('\n✅ Done!\n');
+        }
+        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;
+}