@apollo-annotation/cli 0.1.10

package/dist/commands/config.js

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import path from 'node:path';
+import input from '@inquirer/input';
+import password from '@inquirer/password';
+import select from '@inquirer/select';
+import { Args, Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../baseCommand.js';
+import { Config, ConfigError, KEYS, optionDesc } from '../Config.js';
+import { createFetchErrorMessage, localhostToAddress, wrapLines, } from '../utils.js';
+export default class ApolloConfig extends BaseCommand {
+    static summary = 'Get or set apollo configuration options';
+    static description = wrapLines(`Use this command to create or edit a user profile with credentials to access Apollo. \
+     Configuration options are:
+
+     ${optionDesc().join('\n\n')}`);
+    static args = {
+        key: Args.string({
+            name: 'key',
+            description: 'Name of configuration parameter',
+        }),
+        value: Args.string({
+            name: 'value',
+            description: 'Parameter value',
+        }),
+    };
+    static flags = {
+        profile: Flags.string({
+            description: 'Profile to create or edit',
+            required: false,
+        }),
+        'get-config-file': Flags.boolean({
+            description: 'Return the path to the config file and exit (this file may not exist yet)',
+        }),
+    };
+    static examples = [
+        {
+            description: 'Interactive setup:',
+            command: '<%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: 'Setup with key/value pairs:',
+            command: '<%= config.bin %> <%= command.id %> --profile admin address http://localhost:3999',
+        },
+        {
+            description: 'Get current address for default profile:',
+            command: '<%= config.bin %> <%= command.id %> address',
+        },
+    ];
+    async run() {
+        const { args } = await this.parse(ApolloConfig);
+        const { flags } = await this.parse(ApolloConfig);
+        let configFile = flags['config-file'];
+        configFile =
+            configFile === undefined
+                ? path.join(this.config.configDir, 'config.yaml')
+                : path.resolve(configFile);
+        if (flags['get-config-file']) {
+            this.log(configFile);
+            this.exit(0);
+        }
+        const config = new Config(configFile);
+        if (args.key === undefined) {
+            await this.interactiveSetup(config, flags.profile);
+        }
+        else {
+            let profileName = flags.profile;
+            if (profileName === undefined) {
+                profileName = process.env.APOLLO_PROFILE ?? 'default';
+            }
+            if (flags.profile !== undefined) {
+                profileName = flags.profile;
+            }
+            try {
+                if (args.value === undefined) {
+                    const currentValue = config.get(args.key, profileName);
+                    this.log(currentValue);
+                }
+                else {
+                    config.set(args.key, args.value, profileName);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    this.logToStderr(error.message);
+                }
+                this.exit(1);
+            }
+        }
+        const v = config.validate().error?.message;
+        if (v) {
+            this.logToStderr(v);
+        }
+        try {
+            config.writeConfigFile();
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+    }
+    async interactiveSetup(config, profileName) {
+        if (profileName === undefined) {
+            profileName = await this.askProfileName(config.getProfileNames());
+        }
+        let setMe = true;
+        while (setMe) {
+            const address = await this.askAddress(config.get(KEYS[KEYS.address], profileName));
+            try {
+                config.set('address', address, profileName);
+                setMe = false;
+            }
+            catch (error) {
+                if (error instanceof ConfigError) {
+                    this.logToStderr(error.message);
+                }
+            }
+        }
+        const address = config.get(KEYS[KEYS.address], profileName);
+        let accessType = '';
+        try {
+            accessType = await this.selectAccessType(address);
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+        config.set(KEYS[KEYS.accessType], accessType, profileName);
+        if (accessType === 'root') {
+            const username = await this.askUsername(config.get(KEYS.rootCredentials_username, profileName));
+            config.set('rootCredentials.username', username, profileName);
+            const password = await this.askPassword();
+            config.set('rootCredentials.password', password, profileName);
+        }
+    }
+    async askProfileName(currentProfiles) {
+        const newProfile = '<New profile>';
+        currentProfiles.push(newProfile);
+        const xchoices = [];
+        for (const profileName of currentProfiles) {
+            xchoices.push({ name: profileName, value: profileName });
+        }
+        let answer = newProfile;
+        if (currentProfiles.length > 1) {
+            answer = await select({
+                message: 'Select profile to edit or create a new one:',
+                choices: xchoices,
+            });
+        }
+        if (answer === newProfile) {
+            answer = await input({
+                message: 'New profile name:',
+                default: currentProfiles.includes('default') ? undefined : 'default',
+            });
+        }
+        return answer;
+    }
+    async askPassword() {
+        let answer = '';
+        while (answer === '') {
+            answer = await password({
+                message: 'Root password:',
+                mask: true,
+            });
+            answer = answer.trim();
+        }
+        return answer;
+    }
+    async askUsername(currentUsername) {
+        if (currentUsername === undefined || currentUsername.trim() === '') {
+            currentUsername = 'root';
+        }
+        const answer = await input({
+            message: 'Root username:',
+            default: currentUsername,
+        });
+        return answer.trim();
+    }
+    async askAddress(currentAddress) {
+        if (currentAddress === '' || currentAddress === undefined) {
+            currentAddress = 'http://localhost:3999';
+        }
+        const answer = await input({
+            message: 'Server address and port:',
+            default: currentAddress,
+        });
+        return answer.trim();
+    }
+    async selectAccessType(address) {
+        const xchoices = [{ name: 'root', value: 'root' }];
+        const types = await this.getLoginTypes(address);
+        for (const type of types) {
+            xchoices.push({ name: type, value: type });
+        }
+        const answer = await select({
+            message: 'Select login type',
+            choices: xchoices,
+        });
+        return answer;
+    }
+    async getLoginTypes(address) {
+        const response = await fetch(localhostToAddress(`${address}/auth/types`));
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, `Unable to retrieve login types for address: "${address}"\n`);
+            throw new Error(errorMessage);
+        }
+        const dat = await response.json();
+        if (Array.isArray(dat)) {
+            return dat;
+        }
+        throw new Error(`Unexpected object: ${JSON.stringify(dat)}`);
+    }
+}

package/dist/commands/config.test.d.ts

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

package/dist/commands/config.test.js

@@ -0,0 +1,188 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import fs from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, test } from '@oclif/test';
+import YAML from 'yaml';
+import { CONFIG_FILE, TEST_DATA_DIR, VERBOSE, copyFile, } from '../test/fixtures.js';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe('apollo config: Query config file', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    let cmd = ['config', 'rootCredentials.password'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('1234');
+    });
+    cmd = ['config', 'address'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('http://localhost:3999');
+    });
+    cmd = ['config', 'someInvalidKey'];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('someInvalidKey'))
+        .it(cmd.join(' '));
+    cmd = ['config', '--profile', 'profile1', 'address'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('http://localhost:1999');
+    });
+    cmd = ['config', '--profile', 'profile1', 'rootCredentials.username'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('');
+    });
+    cmd = ['config', '--profile', 'nonExistantProfile', 'address'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('');
+    });
+});
+describe('apollo config: Missing config file', () => {
+    let cmd = ['config', 'rootCredentials.password'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('');
+    });
+    cmd = ['config', 'address'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('');
+    });
+});
+describe('apollo config: Create config directory', () => {
+    const outdir = `${TEST_DATA_DIR}/_tmp`;
+    before(() => {
+        fs.rmSync(outdir, { recursive: true, force: true });
+    });
+    after(() => {
+        fs.rmSync(outdir, { recursive: true, force: true });
+    });
+    const cmd = [
+        'config',
+        '--config-file',
+        `${outdir}/config.yaml`,
+        'address',
+        'http://localhost:3999',
+    ];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        expect(fs.existsSync(`${outdir}/config.yaml`));
+    });
+});
+describe('apollo config: Read & edit config file', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    let cmd = ['config', 'address', 'http://localhost:4321'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.default.address).to.equal('http://localhost:4321');
+        expect(cfg.default.rootCredentials.username).to.equal('root');
+    });
+    cmd = ['config', 'rootCredentials.username', 'root2'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.default.rootCredentials.username).to.equal('root2');
+    });
+    cmd = ['config', 'accessType', 'microsoft'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.default.accessType).to.equal('microsoft');
+    });
+});
+describe('Do not set invalid address', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/complete_config.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    const cmd = ['config', 'address', 'http://localhost:3999xxx'];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('http://localhost:3999xxx'))
+        .it(cmd.join(' '));
+});
+describe('apollo config: Write config file from scratch', () => {
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    let cmd = ['config', 'rootCredentials.username', 'somename'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.default.rootCredentials.username).to.equal('somename');
+    });
+    cmd = [
+        'config',
+        '--profile',
+        'myProfile',
+        'rootCredentials.password',
+        'somepwd',
+    ];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.myProfile.rootCredentials.password).to.equal('somepwd');
+    });
+});
+describe('apollo config: Handle strings as numbers in yaml', () => {
+    const cmd = [
+        'config',
+        '--config-file',
+        'test_data/nameAsNumber.yaml',
+        'rootCredentials.username',
+    ];
+    test
+        .stderr()
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .do((output) => expect(output.stderr).contains('must be a string'))
+        .it(cmd.join(' '), (ctx) => {
+        expect(ctx.stdout.trim()).to.equal('7890');
+    });
+});

package/dist/commands/feature/add-child.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Get extends BaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'feature-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        start: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        end: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private addChild;
+}

package/dist/commands/feature/add-child.js

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/restrict-plus-operands */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { Flags } from '@oclif/core';
+import { ObjectId } from 'bson';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getFeatureById, idReader, localhostToAddress, queryApollo, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Add a child feature (e.g. add an exon to an mRNA)';
+    static description = wrapLines('See the other commands under `apollo feature` to retrive the parent ID of interest and to populate the child feature with attributes.');
+    static examples = [
+        {
+            description: 'Add an exon at genomic coordinates 10..20 to this feature ID:',
+            command: '<%= config.bin %> <%= command.id %> -i 6605826fbd0eee691f83e73f -t exon -s 10 -e 20',
+        },
+    ];
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            default: '-',
+            description: 'Add a child to this feature ID; use - to read it from stdin',
+        }),
+        start: Flags.integer({
+            char: 's',
+            required: true,
+            description: 'Start coordinate of the child feature (1-based)',
+        }),
+        end: Flags.integer({
+            char: 'e',
+            required: true,
+            description: 'End coordinate of the child feature (1-based)',
+        }),
+        type: Flags.string({
+            char: 't',
+            required: true,
+            description: 'Type of child feature',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        if (flags.end < flags.start) {
+            this.logToStderr('Error: End coordinate is lower than the start coordinate');
+            this.exit(1);
+        }
+        if (flags.start <= 0) {
+            this.logToStderr('Coordinates must be greater than 0');
+            this.exit(1);
+        }
+        const ff = idReader([flags['feature-id']]);
+        if (ff.length !== 1) {
+            this.logToStderr(`Expected only one feature identifier. Got ${ff.length}`);
+        }
+        const [featureId] = ff;
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const response = await getFeatureById(access.address, access.accessToken, featureId);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'getFeatureById failed');
+            throw new Error(errorMessage);
+        }
+        const feature = JSON.parse(await response.text());
+        const childRes = await this.addChild(access.address, access.accessToken, feature, flags.start - 1, flags.end, flags.type);
+        if (!childRes.ok) {
+            const obj = JSON.parse(await response.text());
+            const message = obj['message'];
+            this.logToStderr(message);
+            this.exit(1);
+        }
+        this.exit(0);
+    }
+    async addChild(address, accessToken, parentFeature, start, end, type) {
+        const pStart = parentFeature['start'];
+        const pEnd = parentFeature['end'];
+        if (start < pStart || end > pEnd) {
+            this.logToStderr(`Error: Child feature coordinates (${start + 1}-${end}) cannot extend beyond parent coordinates (${pStart + 1}-${pEnd})`);
+            this.exit(1);
+        }
+        const res = await queryApollo(address, accessToken, 'refSeqs');
+        const refSeqs = (await res.json());
+        const refSeq = parentFeature['refSeq'];
+        let assembly = '';
+        for (const x of refSeqs) {
+            if (x['_id'] === refSeq) {
+                assembly = x['assembly'];
+                break;
+            }
+        }
+        const change = {
+            typeName: 'AddFeatureChange',
+            changedIds: [parentFeature['_id']],
+            assembly,
+            addedFeature: {
+                _id: new ObjectId().toHexString(),
+                gffId: '',
+                refSeq,
+                start,
+                end,
+                type,
+            },
+            parentFeatureId: parentFeature['_id'],
+        };
+        const url = new URL(localhostToAddress(`${address}/changes`));
+        const auth = {
+            method: 'POST',
+            body: JSON.stringify(change),
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        const response = await fetch(url, auth);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'getFeatureById failed');
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+}

package/dist/commands/feature/check.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Check extends BaseCommand<typeof Check> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'feature-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/check.js

@@ -0,0 +1,97 @@
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { convertAssemblyNameToId, createFetchErrorMessage, idReader, localhostToAddress, queryApollo, wrapLines, } from '../../utils.js';
+export default class Check extends BaseCommand {
+    static summary = 'Get check results';
+    static description = wrapLines('Use this command to view which features fail checks along with the reason for failing.\
+    Use `apollo assembly check` for managing which checks should be applied to an assembly');
+    static examples = [
+        {
+            description: 'Get all check results in the database:',
+            command: '<%= config.bin %> <%= command.id %>',
+        },
+        {
+            description: 'Get check results for assembly hg19:',
+            command: '<%= config.bin %> <%= command.id %> -a hg19',
+        },
+    ];
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            description: 'Get checks for these feature identifiers',
+            multiple: true,
+        }),
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Get checks for this assembly',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Check);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        let keepFeatures = new Set();
+        if (flags['feature-id'] !== undefined) {
+            keepFeatures = new Set(idReader(flags['feature-id']));
+        }
+        const keepAsmId = await keepAssemblies(access.address, access.accessToken, flags.assembly);
+        const res = await queryApollo(access.address, access.accessToken, 'refseqs');
+        const refseq = (await res.json());
+        const refseqId = new Set();
+        for (const x of refseq) {
+            if (keepAsmId.includes(x['assembly'])) {
+                refseqId.add(x['_id']);
+            }
+        }
+        const checks = await getChecks(access.address, access.accessToken);
+        const results = [];
+        for (const chk of checks) {
+            let keep = false;
+            if (flags['feature-id'] === undefined) {
+                keep = true;
+            }
+            else {
+                for (const x of chk['ids']) {
+                    if (keepFeatures.has(x)) {
+                        keep = true;
+                        break;
+                    }
+                }
+            }
+            if (keep && refseqId.has(chk['refSeq'])) {
+                results.push(chk);
+            }
+        }
+        this.log(JSON.stringify(results, null, 2));
+    }
+}
+async function keepAssemblies(address, accessToken, assembly) {
+    let keepAssembly = [];
+    if (assembly === undefined) {
+        const res = await queryApollo(address, accessToken, 'assemblies');
+        const asm = (await res.json());
+        for (const x of asm) {
+            keepAssembly.push(x['_id']);
+        }
+    }
+    else {
+        const ids = idReader([assembly]);
+        keepAssembly = await convertAssemblyNameToId(address, accessToken, ids);
+    }
+    return keepAssembly;
+}
+async function getChecks(address, token) {
+    const url = new URL(localhostToAddress(`${address}/checks`));
+    const auth = {
+        headers: {
+            authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const response = await fetch(url, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'Failed to access Apollo with the current address and/or access token\nThe server returned:\n');
+        throw new Error(errorMessage);
+    }
+    return (await response.json());
+}

package/dist/commands/feature/copy.d.ts

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Copy extends BaseCommand<typeof Copy> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'feature-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        refseq: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        start: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private copyFeature;
+}