@apollo-annotation/cli 0.1.10

package/dist/commands/feature/copy.js

@@ -0,0 +1,110 @@
+import { Flags } from '@oclif/core';
+import { ObjectId } from 'bson';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getAssemblyFromRefseq, getFeatureById, getRefseqId, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class Copy extends BaseCommand {
+    static summary = 'Copy a feature to another location';
+    static description = wrapLines('The feature may be copied to the same or to a different assembly. \
+    he destination reference sequence may be selected by name only if unique in the database or by name and assembly or by identifier.');
+    static examples = [
+        {
+            description: 'Copy this feature ID to chr1:100 in assembly hg38:',
+            command: '<%= config.bin %> <%= command.id %> -i 6605826fbd0eee691f83e73f -r chr1 -s 100 -a hg38',
+        },
+    ];
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            default: '-',
+            description: 'Feature ID to copy to; use - to read it from stdin',
+        }),
+        refseq: Flags.string({
+            char: 'r',
+            description: 'Name or ID of target reference sequence',
+            required: true,
+        }),
+        start: Flags.integer({
+            char: 's',
+            description: 'Start position in target reference sequence',
+            required: true,
+        }),
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Name or ID of target assembly. Not required if refseq is unique in the database',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Copy);
+        if (flags.start <= 0) {
+            this.logToStderr('Start coordinate must be greater than 0');
+            this.exit(1);
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const response = await getFeatureById(access.address, access.accessToken, flags['feature-id']);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'getFeatureById failed');
+            throw new Error(errorMessage);
+        }
+        const feature = (await response.json());
+        let refseqIds = [];
+        try {
+            refseqIds = await getRefseqId(access.address, access.accessToken, flags.refseq, flags.assembly);
+        }
+        catch (error) {
+            this.logToStderr(error.message);
+            this.exit(1);
+        }
+        if (refseqIds.length === 0) {
+            this.logToStderr('No reference sequence found');
+            this.exit(1);
+        }
+        const [refseq] = refseqIds;
+        const assembly = await getAssemblyFromRefseq(access.address, access.accessToken, refseq);
+        const newId = new ObjectId().toHexString();
+        const rescopy = await this.copyFeature(access.address, access.accessToken, feature, refseq, flags.start, assembly, newId);
+        if (!rescopy.ok) {
+            const message = feature['message'];
+            this.logToStderr(message);
+            this.exit(1);
+        }
+        this.exit(0);
+    }
+    async copyFeature(address, accessToken, feature, refseq, start, assembly, newId) {
+        const featureLen = feature['end'] -
+            feature['start'];
+        const change = {
+            typeName: 'AddFeatureChange',
+            changedIds: [newId],
+            assembly,
+            addedFeature: {
+                _id: newId,
+                refSeq: refseq,
+                start: start - 1,
+                end: start + featureLen - 1,
+                type: feature['type'],
+                attributes: feature['attributes'],
+                discontinuousLocations: feature['discontinuousLocations'],
+                strand: feature['strand'],
+            },
+            copyFeature: true,
+            allIds: [newId],
+        };
+        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, 'copyFeature failed');
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Delete extends BaseCommand<typeof Delete> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        'feature-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/delete.js

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getFeatureById, idReader, localhostToAddress, wrapLines, } from '../../utils.js';
+async function deleteFeature(address, accessToken, feature) {
+    const changeJson = {
+        typeName: 'DeleteFeatureChange',
+        changedIds: [feature],
+        assembly: feature['assembly'],
+        deletedFeature: {
+            _id: feature['_id'],
+            gffId: feature['gffId'],
+            refSeq: feature['refSeq'],
+            type: feature['type'],
+            start: feature['start'],
+            end: feature['end'],
+            discontinuousLocations: feature['discontinuousLocations'],
+            score: feature['score'],
+            attributes: feature['attributes'],
+        },
+    };
+    const url = new URL(localhostToAddress(`${address}/changes`));
+    const auth = {
+        method: 'POST',
+        body: JSON.stringify(changeJson),
+        headers: {
+            authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const response = await fetch(url, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'deleteFeature failed');
+        throw new Error(errorMessage);
+    }
+    return response;
+}
+export default class Delete extends BaseCommand {
+    static summary = 'Delete one or more features by ID';
+    static description = wrapLines('Note that deleting a child feature after deleting its parent will result in an error unless you set -f/--force.');
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            default: ['-'],
+            description: 'Feature IDs to delete',
+            multiple: true,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Ignore non-existing features',
+        }),
+        'dry-run': Flags.boolean({
+            char: 'n',
+            description: 'Only show what would be delete',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Delete);
+        const tmpIds = idReader(flags['feature-id']);
+        const featureIds = new Set();
+        for (const x of tmpIds) {
+            featureIds.add(x);
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        for (const featureId of featureIds) {
+            const response = await getFeatureById(access.address, access.accessToken, featureId);
+            if (response.status === 404 && flags.force) {
+                continue;
+            }
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, 'getFeatureById failed');
+                throw new Error(errorMessage);
+            }
+            const feature = JSON.parse(await response.text());
+            if (!response.ok) {
+                const message = feature['message'];
+                this.logToStderr(message);
+                this.exit(1);
+            }
+            if (flags['dry-run']) {
+                this.log(feature);
+            }
+            else {
+                const delFet = await deleteFeature(access.address, access.accessToken, feature);
+                if (!delFet.ok) {
+                    const json = (await delFet.json());
+                    const message = json['message'];
+                    this.logToStderr(message);
+                    this.exit(1);
+                }
+            }
+        }
+        this.exit(0);
+    }
+}

package/dist/commands/feature/edit-attribute.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class EditAttibute extends BaseCommand<typeof EditAttibute> {
+    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>;
+        attribute: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        delete: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/edit-attribute.js

@@ -0,0 +1,100 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getAssemblyFromRefseq, getFeatureById, idReader, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class EditAttibute extends BaseCommand {
+    static summary = 'Add, edit, or view a feature attribute';
+    static description = wrapLines('Be aware that there is no checking whether attributes names and values are valid. \
+    For example, you can create non-unique ID attributes or you can set gene ontology terms to non-existing terms');
+    static examples = [
+        {
+            description: 'Add attribute "domains" with a list of values:',
+            command: '<%= config.bin %> <%= command.id %> -i 66...3f -a domains -v ABC PLD',
+        },
+        {
+            description: 'Print values in "domains" as json array:',
+            command: '<%= config.bin %> <%= command.id %> -i 66...3f -a domains',
+        },
+        {
+            description: 'Delete attribute "domains"',
+            command: '<%= config.bin %> <%= command.id %> -i 66...3f -a domains -d',
+        },
+    ];
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            default: '-',
+            description: 'Feature ID to edit or "-" to read it from stdin',
+        }),
+        attribute: Flags.string({
+            char: 'a',
+            required: true,
+            description: 'Attribute key to add or edit',
+        }),
+        value: Flags.string({
+            char: 'v',
+            multiple: true,
+            description: 'New attribute value. Separated mutliple values by space to them as a list. If unset return current value',
+        }),
+        delete: Flags.boolean({
+            char: 'd',
+            description: 'Delete this attribute',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EditAttibute);
+        if (flags.delete && flags.value) {
+            this.logToStderr('Error: Options --delete and --value are mutually exclusive');
+            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 featureJson = JSON.parse(await response.text());
+        if (flags.value === undefined && !flags.delete) {
+            this.log(JSON.stringify(featureJson.attributes[flags.attribute]));
+            this.exit(0);
+        }
+        if (flags.delete) {
+            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+            delete featureJson.attributes[flags.attribute];
+        }
+        else {
+            featureJson.attributes[flags.attribute] = flags.value;
+        }
+        const assembly = await getAssemblyFromRefseq(access.address, access.accessToken, featureJson['refSeq']);
+        const changeJson = {
+            typeName: 'FeatureAttributeChange',
+            changedIds: [featureId],
+            assembly,
+            featureId,
+            attributes: featureJson.attributes,
+        };
+        const url = new URL(localhostToAddress(`${access.address}/changes`));
+        const auth = {
+            method: 'POST',
+            body: JSON.stringify(changeJson),
+            headers: {
+                authorization: `Bearer ${access.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        const res = await fetch(url, auth);
+        if (!res.ok) {
+            const errorMessage = await createFetchErrorMessage(res, 'edit-attribute failed');
+            throw new Error(errorMessage);
+        }
+        this.exit(0);
+    }
+}

package/dist/commands/feature/edit-coords.d.ts

@@ -0,0 +1,15 @@
+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 | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        end: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/edit-coords.js

@@ -0,0 +1,109 @@
+/* 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 { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getAssemblyFromRefseq, getFeatureById, idReader, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Edit feature start and/or end coordinates';
+    static description = wrapLines("If editing a child feature that new coordinates must be within the parent's coordinates.\
+    To get the identifier of the feature to edit consider using `apollo feature get` or `apollo feature search`");
+    static examples = [
+        {
+            description: 'Edit start and end:',
+            command: '<%= config.bin %> <%= command.id %> -i abc...xyz -s 10 -e 1000',
+        },
+        {
+            description: 'Edit end and leave start as it is:',
+            command: '<%= config.bin %> <%= command.id %> -i abc...xyz -e 2000',
+        },
+    ];
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            default: '-',
+            description: 'Feature ID to edit or "-" to read it from stdin',
+        }),
+        start: Flags.integer({
+            char: 's',
+            description: 'New start coordinate (1-based)',
+        }),
+        end: Flags.integer({
+            char: 'e',
+            description: 'New end coordinate (1-based)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        if (flags.start === undefined && flags.end === undefined) {
+            this.logToStderr('Please provide new start and/or end coordinates to edit');
+            this.exit(1);
+        }
+        if (flags.start !== undefined && flags.start <= 0) {
+            this.logToStderr('Coordinates must be greater than 0');
+            this.exit(1);
+        }
+        if (flags.start !== undefined &&
+            flags.end !== undefined &&
+            flags.end < flags.start) {
+            this.logToStderr('Error: The new end coordinate is lower than the new start coordinate');
+            this.exit(1);
+        }
+        if (flags.start !== undefined) {
+            flags.start -= 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 featureJson = JSON.parse(await response.text());
+        const assembly = await getAssemblyFromRefseq(access.address, access.accessToken, featureJson['refSeq']);
+        const currentEnd = featureJson['end'];
+        let edit = ['Start', 'End'];
+        if (flags.start !== undefined && flags.start > currentEnd) {
+            // Edit End first so you avoid an intermediate start > end
+            edit = ['End', 'Start'];
+        }
+        for (const coord of edit) {
+            const currentStart = featureJson['start'];
+            if (coord === 'Start' &&
+                (flags.start === undefined || flags.start === currentStart)) {
+                continue;
+            }
+            else if (coord === 'End' &&
+                (flags.end === undefined || flags.end === currentEnd)) {
+                continue;
+            }
+            const changeJson = {
+                typeName: `Location${coord}Change`,
+                changedIds: [featureId],
+                assembly,
+                featureId,
+                [`old${coord}`]: featureJson[coord.toLowerCase()],
+                [`new${coord}`]: flags[coord.toLowerCase()],
+            };
+            const url = new URL(localhostToAddress(`${access.address}/changes`));
+            const auth = {
+                method: 'POST',
+                body: JSON.stringify(changeJson),
+                headers: {
+                    authorization: `Bearer ${access.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+            };
+            const response = await fetch(url, auth);
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, 'edit-coords failed');
+                throw new Error(errorMessage);
+            }
+        }
+    }
+}

package/dist/commands/feature/edit-type.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Get extends BaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static flags: {
+        'feature-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: 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/edit-type.js

@@ -0,0 +1,70 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getAssemblyFromRefseq, getFeatureById, idReader, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Edit or view feature type';
+    static description = wrapLines('Feature type is column 3 in gff format.\
+    It must be a valid sequence ontology term although but the valifdity of the new term is not checked.');
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            default: '-',
+            description: 'Feature ID to edit or "-" to read it from stdin',
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Assign feature to this type. If unset return the current type',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        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 featureJson = JSON.parse(await response.text());
+        const currentType = featureJson['type'];
+        if (flags.type === undefined) {
+            this.log(currentType);
+            this.exit(0);
+        }
+        if (flags.type === currentType) {
+            this.logToStderr(`NOTE: Feature ${featureId} is already of type "${flags.type}"`);
+            this.exit(0);
+        }
+        const assembly = await getAssemblyFromRefseq(access.address, access.accessToken, featureJson['refSeq']);
+        const changeJson = {
+            typeName: 'TypeChange',
+            changedIds: [featureId],
+            assembly,
+            featureId,
+            oldType: currentType,
+            newType: flags.type,
+        };
+        const url = new URL(localhostToAddress(`${access.address}/changes`));
+        const auth = {
+            method: 'POST',
+            body: JSON.stringify(changeJson),
+            headers: {
+                authorization: `Bearer ${access.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        const res = await fetch(url, auth);
+        if (!res.ok) {
+            const errorMessage = await createFetchErrorMessage(res, 'edit-type failed');
+            throw new Error(errorMessage);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+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: {
+        'json-input': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/edit.js

@@ -0,0 +1,81 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import * as fs from 'node:fs';
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Edit features using an appropiate json input';
+    static description = wrapLines(`Edit a feature by submitting a json input with all the required attributes for Apollo to process it. This is a very low level command which most users probably do not need.
+
+    Input may be a json string or a json file and it may be an array of changes. This is an example input for editing feature type:
+
+    {
+      "typeName": "TypeChange",
+      "changedIds": [
+        "6613f7d22c957525d631b1cc"
+      ],
+      "assembly": "6613f7d1360321540a11e5ed",
+      "featureId": "6613f7d22c957525d631b1cc",
+      "oldType": "BAC",
+      "newType": "G_quartet"
+    }`);
+    static examples = [
+        {
+            description: 'Editing by passing a json to stdin:',
+            command: 'echo \'{"typeName": ... "newType": "G_quartet"}\' | <%= config.bin %> <%= command.id %> -j -',
+        },
+    ];
+    static flags = {
+        'json-input': Flags.string({
+            char: 'j',
+            default: '-',
+            description: 'Json string or json file or "-" to read json from stdin',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        let jsonStr = flags['json-input'];
+        if (flags['json-input'] === '-') {
+            jsonStr = fs.readFileSync(process.stdin.fd).toString();
+        }
+        else if (fs.existsSync(flags['json-input'])) {
+            jsonStr = fs.readFileSync(flags['json-input']).toString();
+        }
+        let json;
+        try {
+            json = JSON.parse(jsonStr);
+            if (!Array.isArray(json)) {
+                json = [json];
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.logToStderr(`Error parsing json input:\n${error.message}`);
+                this.exit(1);
+            }
+            else {
+                throw error;
+            }
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        for (const change of json) {
+            const str = JSON.stringify(change);
+            const url = new URL(localhostToAddress(`${access.address}/changes`));
+            const auth = {
+                method: 'POST',
+                body: str,
+                headers: {
+                    authorization: `Bearer ${access.accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+            };
+            const response = await fetch(url, auth);
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, 'edit failed');
+                throw new Error(errorMessage);
+            }
+        }
+        this.exit(0);
+    }
+}

package/dist/commands/feature/get-id.d.ts

@@ -0,0 +1,14 @@
+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>;
+    };
+    run(): Promise<void>;
+    private getFeatureId;
+}