genomic 4.0.2 → 5.0.0

package/esm/licenses.js

@@ -0,0 +1,120 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const PLACEHOLDER_PATTERN = /{{(\w+)}}/g;
+let cachedTemplates = null;
+export const DEFAULT_LICENSE = 'MIT';
+export const CLOSED_LICENSE = 'CLOSED';
+export const LICENSE_VALUE_KEYS = ['LICENSE', 'license'];
+export const LICENSE_AUTHOR_KEYS = [
+    'USERFULLNAME',
+    'AUTHOR',
+    'AUTHORFULLNAME',
+    'USERNAME',
+    'fullName',
+    'author',
+    'authorFullName',
+    'userName',
+];
+export const LICENSE_EMAIL_KEYS = ['USEREMAIL', 'EMAIL', 'email', 'userEmail'];
+export function isSupportedLicense(name) {
+    if (!name) {
+        return false;
+    }
+    return Boolean(loadLicenseTemplates()[name.toUpperCase()]);
+}
+export function renderLicense(licenseName, context) {
+    if (!licenseName) {
+        return null;
+    }
+    const templates = loadLicenseTemplates();
+    const template = templates[licenseName.toUpperCase()];
+    if (!template) {
+        return null;
+    }
+    const ctx = {
+        year: context.year ?? new Date().getFullYear().toString(),
+        author: context.author ?? 'Unknown Author',
+        email: context.email ?? '',
+    };
+    const emailLine = ctx.email ? ` <${ctx.email}>` : '';
+    return template.replace(PLACEHOLDER_PATTERN, (_, rawKey) => {
+        const key = rawKey.toUpperCase();
+        if (key === 'EMAIL_LINE') {
+            return emailLine;
+        }
+        const normalizedKey = key.toLowerCase();
+        const value = ctx[normalizedKey];
+        return value || '';
+    });
+}
+export function listSupportedLicenses() {
+    const licenses = Object.keys(loadLicenseTemplates());
+    // Sort with DEFAULT_LICENSE first, CLOSED_LICENSE last, then alphabetically
+    return licenses.sort((a, b) => {
+        if (a === DEFAULT_LICENSE)
+            return -1;
+        if (b === DEFAULT_LICENSE)
+            return 1;
+        if (a === CLOSED_LICENSE)
+            return 1;
+        if (b === CLOSED_LICENSE)
+            return -1;
+        return a.localeCompare(b);
+    });
+}
+export function findLicenseValue(answers) {
+    return getAnswerValue(answers, LICENSE_VALUE_KEYS);
+}
+export function findLicenseAuthor(answers) {
+    return getAnswerValue(answers, LICENSE_AUTHOR_KEYS);
+}
+export function findLicenseEmail(answers) {
+    return getAnswerValue(answers, LICENSE_EMAIL_KEYS);
+}
+function loadLicenseTemplates() {
+    if (cachedTemplates) {
+        return cachedTemplates;
+    }
+    const dir = findTemplatesDir();
+    if (!dir) {
+        cachedTemplates = {};
+        return cachedTemplates;
+    }
+    const files = fs.readdirSync(dir);
+    const templates = {};
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        const stats = fs.statSync(fullPath);
+        if (!stats.isFile()) {
+            continue;
+        }
+        if (path.extname(file).toLowerCase() !== '.txt') {
+            continue;
+        }
+        const key = path.basename(file, path.extname(file)).toUpperCase();
+        templates[key] = fs.readFileSync(fullPath, 'utf8');
+    }
+    cachedTemplates = templates;
+    return cachedTemplates;
+}
+function findTemplatesDir() {
+    const candidates = [
+        path.resolve(__dirname, '..', 'licenses-templates'),
+        path.resolve(__dirname, 'licenses-templates'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function getAnswerValue(answers, keys) {
+    for (const key of keys) {
+        const value = answers?.[key];
+        if (typeof value === 'string' && value.trim() !== '') {
+            return value;
+        }
+    }
+    return undefined;
+}

package/esm/scaffolder/index.js

@@ -0,0 +1,2 @@
+export * from './template-scaffolder';
+export * from './types';

package/esm/scaffolder/template-scaffolder.js

@@ -0,0 +1,310 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { CacheManager } from '../cache/cache-manager';
+import { GitCloner } from '../git/git-cloner';
+import { Templatizer } from '../template/templatizer';
+/**
+ * High-level orchestrator for template scaffolding operations.
+ * Combines CacheManager, GitCloner, and Templatizer into a single, easy-to-use API.
+ *
+ * @example
+ * ```typescript
+ * const scaffolder = new TemplateScaffolder({
+ *   toolName: 'my-cli',
+ *   defaultRepo: 'https://github.com/org/templates.git',
+ *   ttlMs: 7 * 24 * 60 * 60 * 1000, // 1 week
+ * });
+ *
+ * await scaffolder.scaffold({
+ *   outputDir: './my-project',
+ *   fromPath: 'starter',
+ *   answers: { name: 'my-project' },
+ * });
+ * ```
+ */
+export class TemplateScaffolder {
+    config;
+    cacheManager;
+    gitCloner;
+    templatizer;
+    constructor(config) {
+        if (!config.toolName) {
+            throw new Error('TemplateScaffolder requires toolName in config');
+        }
+        this.config = config;
+        this.cacheManager = new CacheManager({
+            toolName: config.toolName,
+            ttl: config.ttlMs,
+            baseDir: config.cacheBaseDir,
+        });
+        this.gitCloner = new GitCloner();
+        this.templatizer = new Templatizer();
+    }
+    /**
+     * Scaffold a new project from a template.
+     *
+     * Handles both local directories and remote git repositories.
+     * For remote repos, caching is used to avoid repeated cloning.
+     *
+     * @param options - Scaffold options
+     * @returns Scaffold result with output path and metadata
+     */
+    async scaffold(options) {
+        const template = options.template ?? this.config.defaultRepo;
+        if (!template) {
+            throw new Error('No template specified and no defaultRepo configured. ' +
+                'Either pass template in options or set defaultRepo in config.');
+        }
+        const branch = options.branch ?? this.config.defaultBranch;
+        const resolvedTemplate = this.resolveTemplatePath(template);
+        if (this.isLocalPath(resolvedTemplate) && fs.existsSync(resolvedTemplate)) {
+            return this.scaffoldFromLocal(resolvedTemplate, options);
+        }
+        return this.scaffoldFromRemote(resolvedTemplate, branch, options);
+    }
+    /**
+     * Inspect a template without scaffolding.
+     * Clones/caches the template and reads its .boilerplate.json configuration
+     * without copying any files to an output directory.
+     *
+     * This is useful for metadata-driven workflows where you need to know
+     * the template's type or other configuration before deciding how to handle it.
+     *
+     * @param options - Inspect options
+     * @returns Inspect result with template metadata
+     */
+    inspect(options) {
+        const template = options.template ?? this.config.defaultRepo;
+        if (!template) {
+            throw new Error('No template specified and no defaultRepo configured. ' +
+                'Either pass template in options or set defaultRepo in config.');
+        }
+        const branch = options.branch ?? this.config.defaultBranch;
+        const resolvedTemplate = this.resolveTemplatePath(template);
+        const useBoilerplatesConfig = options.useBoilerplatesConfig ?? true;
+        if (this.isLocalPath(resolvedTemplate) && fs.existsSync(resolvedTemplate)) {
+            return this.inspectLocal(resolvedTemplate, options.fromPath, useBoilerplatesConfig);
+        }
+        return this.inspectRemote(resolvedTemplate, branch, options.fromPath, useBoilerplatesConfig);
+    }
+    /**
+     * Read the .boilerplates.json configuration from a template repository root.
+     */
+    readBoilerplatesConfig(templateDir) {
+        const configPath = path.join(templateDir, '.boilerplates.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const content = fs.readFileSync(configPath, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Read the .boilerplate.json configuration from a boilerplate directory.
+     */
+    readBoilerplateConfig(boilerplatePath) {
+        const jsonPath = path.join(boilerplatePath, '.boilerplate.json');
+        if (fs.existsSync(jsonPath)) {
+            try {
+                const content = fs.readFileSync(jsonPath, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get the underlying CacheManager instance for advanced cache operations.
+     */
+    getCacheManager() {
+        return this.cacheManager;
+    }
+    /**
+     * Get the underlying GitCloner instance for advanced git operations.
+     */
+    getGitCloner() {
+        return this.gitCloner;
+    }
+    /**
+     * Get the underlying Templatizer instance for advanced template operations.
+     */
+    getTemplatizer() {
+        return this.templatizer;
+    }
+    inspectLocal(templateDir, fromPath, useBoilerplatesConfig = true) {
+        const { fromPath: resolvedFromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, fromPath, useBoilerplatesConfig);
+        const config = this.readBoilerplateConfig(resolvedTemplatePath);
+        return {
+            templateDir,
+            resolvedFromPath,
+            resolvedTemplatePath,
+            cacheUsed: false,
+            cacheExpired: false,
+            config,
+        };
+    }
+    inspectRemote(templateUrl, branch, fromPath, useBoilerplatesConfig = true) {
+        const normalizedUrl = this.gitCloner.normalizeUrl(templateUrl);
+        const cacheKey = this.cacheManager.createKey(normalizedUrl, branch);
+        const expiredMetadata = this.cacheManager.checkExpiration(cacheKey);
+        if (expiredMetadata) {
+            this.cacheManager.clear(cacheKey);
+        }
+        let templateDir;
+        let cacheUsed = false;
+        const cachedPath = this.cacheManager.get(cacheKey);
+        if (cachedPath && !expiredMetadata) {
+            templateDir = cachedPath;
+            cacheUsed = true;
+        }
+        else {
+            const tempDest = path.join(this.cacheManager.getReposDir(), cacheKey);
+            this.gitCloner.clone(normalizedUrl, tempDest, {
+                branch,
+                depth: 1,
+                singleBranch: true,
+            });
+            this.cacheManager.set(cacheKey, tempDest);
+            templateDir = tempDest;
+        }
+        const { fromPath: resolvedFromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, fromPath, useBoilerplatesConfig);
+        const config = this.readBoilerplateConfig(resolvedTemplatePath);
+        return {
+            templateDir,
+            resolvedFromPath,
+            resolvedTemplatePath,
+            cacheUsed,
+            cacheExpired: Boolean(expiredMetadata),
+            config,
+        };
+    }
+    async scaffoldFromLocal(templateDir, options) {
+        const { fromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, options.fromPath, options.useBoilerplatesConfig ?? true);
+        const boilerplateConfig = this.readBoilerplateConfig(resolvedTemplatePath);
+        const result = await this.templatizer.process(templateDir, options.outputDir, {
+            argv: options.answers,
+            noTty: options.noTty,
+            fromPath,
+            prompter: options.prompter,
+        });
+        return {
+            outputDir: result.outputDir,
+            cacheUsed: false,
+            cacheExpired: false,
+            templateDir,
+            fromPath,
+            questions: boilerplateConfig?.questions,
+            answers: result.answers,
+        };
+    }
+    async scaffoldFromRemote(templateUrl, branch, options) {
+        const normalizedUrl = this.gitCloner.normalizeUrl(templateUrl);
+        const cacheKey = this.cacheManager.createKey(normalizedUrl, branch);
+        const expiredMetadata = this.cacheManager.checkExpiration(cacheKey);
+        if (expiredMetadata) {
+            this.cacheManager.clear(cacheKey);
+        }
+        let templateDir;
+        let cacheUsed = false;
+        const cachedPath = this.cacheManager.get(cacheKey);
+        if (cachedPath && !expiredMetadata) {
+            templateDir = cachedPath;
+            cacheUsed = true;
+        }
+        else {
+            const tempDest = path.join(this.cacheManager.getReposDir(), cacheKey);
+            this.gitCloner.clone(normalizedUrl, tempDest, {
+                branch,
+                depth: 1,
+                singleBranch: true,
+            });
+            this.cacheManager.set(cacheKey, tempDest);
+            templateDir = tempDest;
+        }
+        const { fromPath, resolvedTemplatePath } = this.resolveFromPath(templateDir, options.fromPath, options.useBoilerplatesConfig ?? true);
+        const boilerplateConfig = this.readBoilerplateConfig(resolvedTemplatePath);
+        const result = await this.templatizer.process(templateDir, options.outputDir, {
+            argv: options.answers,
+            noTty: options.noTty,
+            fromPath,
+            prompter: options.prompter,
+        });
+        return {
+            outputDir: result.outputDir,
+            cacheUsed,
+            cacheExpired: Boolean(expiredMetadata),
+            templateDir,
+            fromPath,
+            questions: boilerplateConfig?.questions,
+            answers: result.answers,
+        };
+    }
+    /**
+     * Resolve the fromPath using .boilerplates.json convention.
+     *
+     * Resolution order:
+     * 1. If explicit fromPath is provided and exists, use it directly
+     * 2. If useBoilerplatesConfig is true and .boilerplates.json exists with a dir field, prepend it to fromPath
+     * 3. Return the fromPath as-is
+     *
+     * @param templateDir - The template repository root directory
+     * @param fromPath - The subdirectory path to resolve
+     * @param useBoilerplatesConfig - Whether to use .boilerplates.json for fallback resolution (default: true)
+     */
+    resolveFromPath(templateDir, fromPath, useBoilerplatesConfig = true) {
+        if (!fromPath) {
+            return {
+                fromPath: undefined,
+                resolvedTemplatePath: templateDir,
+            };
+        }
+        const directPath = path.isAbsolute(fromPath)
+            ? fromPath
+            : path.join(templateDir, fromPath);
+        if (fs.existsSync(directPath) && fs.statSync(directPath).isDirectory()) {
+            return {
+                fromPath: path.isAbsolute(fromPath) ? path.relative(templateDir, fromPath) : fromPath,
+                resolvedTemplatePath: directPath,
+            };
+        }
+        // Only check .boilerplates.json if useBoilerplatesConfig is true
+        if (useBoilerplatesConfig) {
+            const rootConfig = this.readBoilerplatesConfig(templateDir);
+            if (rootConfig?.dir) {
+                const configBasedPath = path.join(templateDir, rootConfig.dir, fromPath);
+                if (fs.existsSync(configBasedPath) && fs.statSync(configBasedPath).isDirectory()) {
+                    return {
+                        fromPath: path.join(rootConfig.dir, fromPath),
+                        resolvedTemplatePath: configBasedPath,
+                    };
+                }
+            }
+        }
+        return {
+            fromPath,
+            resolvedTemplatePath: path.join(templateDir, fromPath),
+        };
+    }
+    isLocalPath(value) {
+        return (value.startsWith('.') ||
+            value.startsWith('/') ||
+            value.startsWith('~') ||
+            (process.platform === 'win32' && /^[a-zA-Z]:/.test(value)));
+    }
+    resolveTemplatePath(template) {
+        if (this.isLocalPath(template)) {
+            if (template.startsWith('~')) {
+                const home = process.env.HOME || process.env.USERPROFILE || '';
+                return path.join(home, template.slice(1));
+            }
+            return path.resolve(template);
+        }
+        return template;
+    }
+}

package/esm/scaffolder/types.js

@@ -0,0 +1 @@
+export {};

package/esm/template/extract.js

@@ -0,0 +1,162 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const PLACEHOLDER_BOUNDARY = '____';
+/**
+ * Pattern to match ____variable____ in filenames and content
+ */
+const VARIABLE_PATTERN = new RegExp(`${PLACEHOLDER_BOUNDARY}([A-Za-z_][A-Za-z0-9_]*)${PLACEHOLDER_BOUNDARY}`, 'g');
+/**
+ * Extract all variables from a template directory
+ * @param templateDir - Path to the template directory
+ * @returns Extracted variables including file replacers, content replacers, and project questions
+ */
+export async function extractVariables(templateDir) {
+    const fileReplacers = [];
+    const contentReplacers = [];
+    const fileReplacerVars = new Set();
+    const contentReplacerVars = new Set();
+    const projectQuestions = await loadProjectQuestions(templateDir);
+    await walkDirectory(templateDir, async (filePath) => {
+        const relativePath = path.relative(templateDir, filePath);
+        // Skip boilerplate configuration files from variable extraction
+        if (relativePath === '.boilerplate.json' ||
+            relativePath === '.boilerplate.js' ||
+            relativePath === '.boilerplates.json') {
+            return;
+        }
+        const matches = relativePath.matchAll(VARIABLE_PATTERN);
+        for (const match of matches) {
+            const varName = match[1];
+            if (!fileReplacerVars.has(varName)) {
+                fileReplacerVars.add(varName);
+                fileReplacers.push({
+                    variable: varName,
+                    pattern: new RegExp(`${PLACEHOLDER_BOUNDARY}${varName}${PLACEHOLDER_BOUNDARY}`, 'g'),
+                });
+            }
+        }
+        const contentVars = await extractFromFileContent(filePath);
+        for (const varName of contentVars) {
+            if (!contentReplacerVars.has(varName)) {
+                contentReplacerVars.add(varName);
+                contentReplacers.push({
+                    variable: varName,
+                    pattern: new RegExp(`${PLACEHOLDER_BOUNDARY}${varName}${PLACEHOLDER_BOUNDARY}`, 'g'),
+                });
+            }
+        }
+    });
+    return {
+        fileReplacers,
+        contentReplacers,
+        projectQuestions,
+    };
+}
+/**
+ * Extract variables from file content using streams
+ * @param filePath - Path to the file
+ * @returns Set of variable names found in the file
+ */
+async function extractFromFileContent(filePath) {
+    const variables = new Set();
+    return new Promise((resolve) => {
+        const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
+        let buffer = '';
+        stream.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep the last incomplete line in buffer
+            for (const line of lines) {
+                const matches = line.matchAll(VARIABLE_PATTERN);
+                for (const match of matches) {
+                    variables.add(match[1]);
+                }
+            }
+        });
+        stream.on('end', () => {
+            const matches = buffer.matchAll(VARIABLE_PATTERN);
+            for (const match of matches) {
+                variables.add(match[1]);
+            }
+            resolve(variables);
+        });
+        stream.on('error', () => {
+            resolve(variables);
+        });
+    });
+}
+/**
+ * Walk through a directory recursively
+ * @param dir - Directory to walk
+ * @param callback - Callback function for each file
+ */
+async function walkDirectory(dir, callback) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkDirectory(fullPath, callback);
+        }
+        else if (entry.isFile()) {
+            await callback(fullPath);
+        }
+    }
+}
+/**
+ * Load project questions from .boilerplate.json or .boilerplate.js
+ * @param templateDir - Path to the template directory
+ * @returns Questions object or null if not found
+ */
+async function loadProjectQuestions(templateDir) {
+    const jsonPath = path.join(templateDir, '.boilerplate.json');
+    if (fs.existsSync(jsonPath)) {
+        try {
+            const content = fs.readFileSync(jsonPath, 'utf8');
+            const parsed = JSON.parse(content);
+            // .boilerplate.json has { questions: [...] } structure
+            const questions = parsed.questions ? { questions: parsed.questions } : parsed;
+            return validateQuestions(questions) ? normalizeQuestions(questions) : null;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to parse .boilerplate.json: ${errorMessage}`);
+        }
+    }
+    const jsPath = path.join(templateDir, '.boilerplate.js');
+    if (fs.existsSync(jsPath)) {
+        try {
+            const module = require(jsPath);
+            const exported = module.default || module;
+            // .boilerplate.js can export { questions: [...] } or just the questions array
+            const questions = exported.questions ? { questions: exported.questions } : exported;
+            return validateQuestions(questions) ? normalizeQuestions(questions) : null;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn(`Failed to load .boilerplate.js: ${errorMessage}`);
+        }
+    }
+    return null;
+}
+/**
+ * Normalize questions by ensuring all required fields have default values
+ * @param questions - Questions object to normalize
+ * @returns Normalized questions object
+ */
+function normalizeQuestions(questions) {
+    return {
+        ...questions,
+        questions: questions.questions.map((q) => ({
+            ...q,
+            type: q.type || 'text'
+        }))
+    };
+}
+/**
+ * Validate that the questions object has the correct structure
+ * @param obj - Object to validate
+ * @returns True if valid, false otherwise
+ */
+function validateQuestions(obj) {
+    return obj && typeof obj === 'object' && Array.isArray(obj.questions);
+}

package/esm/template/prompt.js

@@ -0,0 +1,103 @@
+import { Inquirerer } from 'inquirerer';
+const PLACEHOLDER_BOUNDARY = '____';
+/**
+ * Generate questions from extracted variables
+ * @param extractedVariables - Variables extracted from the template
+ * @returns Array of questions to prompt the user
+ */
+export function generateQuestions(extractedVariables) {
+    const questions = [];
+    const askedVariables = new Set();
+    if (extractedVariables.projectQuestions) {
+        for (const question of extractedVariables.projectQuestions.questions) {
+            const normalizedName = normalizeQuestionName(question.name);
+            question.name = normalizedName;
+            questions.push(question);
+            askedVariables.add(normalizedName);
+        }
+    }
+    for (const replacer of extractedVariables.fileReplacers) {
+        if (!askedVariables.has(replacer.variable)) {
+            questions.push({
+                name: replacer.variable,
+                type: 'text',
+                message: `Enter value for ${replacer.variable}:`,
+                required: true
+            });
+            askedVariables.add(replacer.variable);
+        }
+    }
+    for (const replacer of extractedVariables.contentReplacers) {
+        if (!askedVariables.has(replacer.variable)) {
+            questions.push({
+                name: replacer.variable,
+                type: 'text',
+                message: `Enter value for ${replacer.variable}:`,
+                required: true
+            });
+            askedVariables.add(replacer.variable);
+        }
+    }
+    return questions;
+}
+function normalizeQuestionName(name) {
+    if (name.startsWith(PLACEHOLDER_BOUNDARY) &&
+        name.endsWith(PLACEHOLDER_BOUNDARY)) {
+        return name.slice(PLACEHOLDER_BOUNDARY.length, -PLACEHOLDER_BOUNDARY.length);
+    }
+    if (name.startsWith('__') && name.endsWith('__')) {
+        return name.slice(2, -2);
+    }
+    return name;
+}
+/**
+ * Prompt the user for variable values
+ * @param extractedVariables - Variables extracted from the template
+ * @param argv - Command-line arguments to pre-populate answers
+ * @param existingPrompter - Optional existing Prompter instance to reuse.
+ *   If provided, the caller retains ownership and must close it themselves.
+ *   If not provided, a new instance is created and closed automatically.
+ * @param noTty - Whether to disable TTY mode (only used when creating a new prompter)
+ * @returns Answers from the user
+ */
+export async function promptUser(extractedVariables, argv = {}, existingPrompter, noTty = false) {
+    const questions = generateQuestions(extractedVariables);
+    if (questions.length === 0) {
+        return argv;
+    }
+    const preparedArgv = mapArgvToQuestions(argv, questions);
+    // If an existing prompter is provided, use it (caller owns lifecycle)
+    // Otherwise, create a new one and close it when done
+    const prompter = existingPrompter ?? new Inquirerer({ noTty });
+    const shouldClose = !existingPrompter;
+    try {
+        const promptAnswers = await prompter.prompt(preparedArgv, questions);
+        return {
+            ...argv,
+            ...promptAnswers,
+        };
+    }
+    finally {
+        if (shouldClose) {
+            prompter.close();
+        }
+    }
+}
+function mapArgvToQuestions(argv, questions) {
+    if (!questions.length) {
+        return argv;
+    }
+    const prepared = { ...argv };
+    const argvEntries = Object.entries(argv);
+    for (const question of questions) {
+        const name = question.name;
+        if (prepared[name] !== undefined) {
+            continue;
+        }
+        const match = argvEntries.find(([key]) => key === name);
+        if (match) {
+            prepared[name] = match[1];
+        }
+    }
+    return prepared;
+}