@jbrowse/cli 3.5.1 → 3.6.1

package/dist/commands/sort-gff-utils/sort-utils.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMinimalEnvironment = getMinimalEnvironment;
+exports.createSortCommandForStdin = createSortCommandForStdin;
+exports.createSortCommandForFile = createSortCommandForFile;
+exports.spawnSortProcessFromFile = spawnSortProcessFromFile;
+exports.spawnSortProcessFromStdin = spawnSortProcessFromStdin;
+exports.spawnSortProcess = spawnSortProcess;
+const child_process_1 = require("child_process");
+const tmp_1 = __importDefault(require("tmp"));
+function getMinimalEnvironment() {
+    return {
+        ...process.env,
+        LC_ALL: 'C',
+    };
+}
+function createSortCommandForStdin() {
+    // Create a temporary file to store stdin content, then process it
+    // This allows us to read the data twice - once for headers, once for sorting
+    const tmpFile = tmp_1.default.fileSync({
+        prefix: 'jbrowse-sort-gff',
+    }).name;
+    const sortCmd = `sort -t"\`printf '\\t'\`" -k1,1 -k4,4n`;
+    // Save stdin to temp file, extract headers, sort non-headers, then cleanup
+    return `cat > ${tmpFile} && (grep "^#" ${tmpFile}; grep -v "^#" ${tmpFile} | ${sortCmd}) && rm -f ${tmpFile}`;
+}
+function createSortCommandForFile(file) {
+    // When reading from a file, we can read it multiple times directly
+    // Need to wrap in parentheses to ensure both grep outputs are combined
+    return `(grep "^#" "${file}"; grep -v "^#" "${file}" | sort -t"\`printf '\\t'\`" -k1,1 -k4,4n)`;
+}
+function spawnSortProcessFromFile(file) {
+    const command = createSortCommandForFile(file);
+    const env = getMinimalEnvironment();
+    return (0, child_process_1.spawn)('sh', ['-c', command], {
+        env,
+        stdio: 'inherit',
+    });
+}
+function spawnSortProcessFromStdin() {
+    const command = createSortCommandForStdin();
+    const env = getMinimalEnvironment();
+    return (0, child_process_1.spawn)('sh', ['-c', command], {
+        env,
+        stdio: 'inherit',
+    });
+}
+function spawnSortProcess(options) {
+    return options.file
+        ? spawnSortProcessFromFile(options.file)
+        : spawnSortProcessFromStdin();
+}

package/dist/commands/sort-gff-utils/validators.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFileArgument = validateFileArgument;
+exports.validateRequiredCommands = validateRequiredCommands;
+const command_exists_1 = require("command-exists");
+function validateFileArgument(file) {
+    // Allow no file argument for stdin input
+    if (!file && process.stdin.isTTY) {
+        console.error('Error: Missing required argument: file');
+        console.error('Usage: jbrowse sort-gff <file>');
+        console.error('       OR pipe data via stdin: cat file.gff | jbrowse sort-gff');
+        process.exit(1);
+    }
+}
+function validateRequiredCommands() {
+    const requiredCommands = ['sh', 'sort', 'grep'];
+    const missingCommands = requiredCommands.filter(cmd => !(0, command_exists_1.sync)(cmd));
+    if (missingCommands.length > 0) {
+        throw new Error('Error: Unable to sort, requires unix type environment with sort, grep');
+    }
+}

package/dist/commands/sort-gff.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const constants_1 = require("./sort-gff-utils/constants");
+const process_utils_1 = require("./sort-gff-utils/process-utils");
+const sort_utils_1 = require("./sort-gff-utils/sort-utils");
+const validators_1 = require("./sort-gff-utils/validators");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+    };
+    const { values: flags, positionals } = (0, util_1.parseArgs)({
+        args,
+        options,
+        allowPositionals: true,
+    });
+    const description = constants_1.SORT_GFF_DESCRIPTION;
+    const examples = constants_1.SORT_GFF_EXAMPLES;
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse sort-gff [file] [options]',
+            options,
+        });
+        return;
+    }
+    const file = positionals[0];
+    if (file) {
+        (0, validators_1.validateFileArgument)(file);
+    }
+    (0, validators_1.validateRequiredCommands)();
+    try {
+        const child = (0, sort_utils_1.spawnSortProcess)({ file: file || '-' });
+        const exitCode = await (0, process_utils_1.waitForProcessClose)(child);
+        if (exitCode !== 0) {
+            console.error(`Sort process exited with code ${exitCode}`);
+            process.exit(exitCode || 1);
+        }
+    }
+    catch (error) {
+        (0, process_utils_1.handleProcessError)(error);
+    }
+}

package/dist/commands/text-index-utils/adapter-utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoc = getLoc;
+exports.createTrixAdapter = createTrixAdapter;
+exports.createPerTrackTrixAdapter = createPerTrackTrixAdapter;
+exports.getAdapterLocation = getAdapterLocation;
+function getLoc(elt) {
+    return elt.locationType === 'LocalPathLocation' ? elt.localPath : elt.uri;
+}
+function createTrixAdapter(id, asm, assemblyNames) {
+    return {
+        type: 'TrixTextSearchAdapter',
+        textSearchAdapterId: id,
+        ixFilePath: {
+            uri: `trix/${asm}.ix`,
+            locationType: 'UriLocation',
+        },
+        ixxFilePath: {
+            uri: `trix/${asm}.ixx`,
+            locationType: 'UriLocation',
+        },
+        metaFilePath: {
+            uri: `trix/${asm}_meta.json`,
+            locationType: 'UriLocation',
+        },
+        assemblyNames: assemblyNames || [asm],
+    };
+}
+function createPerTrackTrixAdapter(trackId, assemblyNames) {
+    return {
+        type: 'TrixTextSearchAdapter',
+        textSearchAdapterId: `${trackId}-index`,
+        ixFilePath: {
+            uri: `trix/${trackId}.ix`,
+            locationType: 'UriLocation',
+        },
+        ixxFilePath: {
+            uri: `trix/${trackId}.ixx`,
+            locationType: 'UriLocation',
+        },
+        metaFilePath: {
+            uri: `trix/${trackId}_meta.json`,
+            locationType: 'UriLocation',
+        },
+        assemblyNames: assemblyNames,
+    };
+}
+function getAdapterLocation(adapter) {
+    const { type } = adapter || {};
+    if (type === 'Gff3TabixAdapter') {
+        return adapter.gffGzLocation || adapter;
+    }
+    else if (type === 'Gff3Adapter') {
+        return adapter.gffLocation || adapter;
+    }
+    else if (type === 'VcfAdapter') {
+        return adapter.vcfLocation || adapter;
+    }
+    else if (type === 'VcfTabixAdapter') {
+        return adapter.vcfGzLocation || adapter;
+    }
+    return undefined;
+}

package/dist/commands/text-index-utils/aggregate.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateIndex = aggregateIndex;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_utils_1 = require("./config-utils");
+const indexing_utils_1 = require("./indexing-utils");
+async function aggregateIndex(flags) {
+    const { out, target, tracks, assemblies, attributes, quiet, force, exclude, dryrun, prefixSize, } = flags;
+    const outFlag = target || out || '.';
+    const isDir = fs_1.default.lstatSync(outFlag).isDirectory();
+    const confPath = isDir ? path_1.default.join(outFlag, 'config.json') : outFlag;
+    const outLocation = path_1.default.dirname(confPath);
+    const config = (0, config_utils_1.readConf)(confPath);
+    const trixDir = path_1.default.join(outLocation, 'trix');
+    if (!fs_1.default.existsSync(trixDir)) {
+        fs_1.default.mkdirSync(trixDir);
+    }
+    const aggregateTextSearchAdapters = config.aggregateTextSearchAdapters || [];
+    const asms = assemblies?.split(',') ||
+        config.assemblies?.map(a => a.name) ||
+        (config.assembly ? [config.assembly.name] : []);
+    if (!asms.length) {
+        throw new Error('No assemblies found');
+    }
+    for (const asm of asms) {
+        const trackConfigs = (0, config_utils_1.getTrackConfigs)(confPath, tracks?.split(','), asm);
+        if (!trackConfigs.length) {
+            console.log(`Indexing assembly ${asm}...(no tracks found)...`);
+            continue;
+        }
+        console.log(`Indexing assembly ${asm}...`);
+        if (dryrun) {
+            console.log(trackConfigs.map(e => `${e.trackId}	${e.adapter?.type}`).join('\n'));
+        }
+        else {
+            const id = `${asm}-index`;
+            const idx = aggregateTextSearchAdapters.findIndex(x => x.textSearchAdapterId === id);
+            if (idx !== -1 && !force) {
+                console.log(`Note: ${asm} has already been indexed with this configuration, use --force to overwrite this assembly. Skipping for now`);
+                continue;
+            }
+            await (0, indexing_utils_1.indexDriver)({
+                trackConfigs,
+                outLocation,
+                quiet,
+                name: asm,
+                attributes: attributes.split(','),
+                typesToExclude: exclude.split(','),
+                assemblyNames: [asm],
+                prefixSize,
+            });
+            const trixConf = {
+                type: 'TrixTextSearchAdapter',
+                textSearchAdapterId: id,
+                ixFilePath: {
+                    uri: `trix/${asm}.ix`,
+                    locationType: 'UriLocation',
+                },
+                ixxFilePath: {
+                    uri: `trix/${asm}.ixx`,
+                    locationType: 'UriLocation',
+                },
+                metaFilePath: {
+                    uri: `trix/${asm}_meta.json`,
+                    locationType: 'UriLocation',
+                },
+                assemblyNames: [asm],
+            };
+            if (idx === -1) {
+                aggregateTextSearchAdapters.push(trixConf);
+            }
+            else {
+                aggregateTextSearchAdapters[idx] = trixConf;
+            }
+        }
+    }
+    if (!dryrun) {
+        (0, config_utils_1.writeConf)({
+            ...config,
+            aggregateTextSearchAdapters,
+        }, confPath);
+    }
+}

package/dist/commands/text-index-utils/config-utils.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readConf = readConf;
+exports.writeConf = writeConf;
+exports.getConfigPath = getConfigPath;
+exports.ensureTrixDir = ensureTrixDir;
+exports.getAssemblyNames = getAssemblyNames;
+exports.getTrackConfigs = getTrackConfigs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const common_1 = require("../../types/common");
+function readConf(configPath) {
+    return JSON.parse(fs_1.default.readFileSync(configPath, 'utf8'));
+}
+function writeConf(obj, configPath) {
+    fs_1.default.writeFileSync(configPath, JSON.stringify(obj, null, 2));
+}
+function getConfigPath(outFlag) {
+    const isDir = fs_1.default.lstatSync(outFlag).isDirectory();
+    const configPath = isDir ? path_1.default.join(outFlag, 'config.json') : outFlag;
+    const outLocation = path_1.default.dirname(configPath);
+    return { configPath, outLocation };
+}
+function ensureTrixDir(outLocation) {
+    const trixDir = path_1.default.join(outLocation, 'trix');
+    if (!fs_1.default.existsSync(trixDir)) {
+        fs_1.default.mkdirSync(trixDir);
+    }
+    return trixDir;
+}
+function getAssemblyNames(config, assemblies) {
+    const asms = assemblies?.split(',') ||
+        config.assemblies?.map(a => a.name) ||
+        (config.assembly ? [config.assembly.name] : []);
+    if (!asms.length) {
+        throw new Error('No assemblies found');
+    }
+    return asms;
+}
+function getTrackConfigs(configPath, trackIds, assemblyName) {
+    const { tracks } = readConf(configPath);
+    if (!tracks) {
+        return [];
+    }
+    const trackIdsToIndex = trackIds || tracks.map(track => track.trackId);
+    return trackIdsToIndex
+        .map(trackId => {
+        const currentTrack = tracks.find(t => trackId === t.trackId);
+        if (!currentTrack) {
+            throw new Error(`Track not found in config.json for trackId ${trackId}, please add track configuration before indexing.`);
+        }
+        return currentTrack;
+    })
+        .filter(track => (0, common_1.supported)(track.adapter?.type))
+        .filter(track => assemblyName ? track.assemblyNames.includes(assemblyName) : true);
+}

package/dist/commands/text-index-utils/file-list.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexFileList = indexFileList;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const indexing_utils_1 = require("./indexing-utils");
+const validators_1 = require("./validators");
+async function indexFileList(flags) {
+    const { out, target, fileId, file, attributes, quiet, exclude, prefixSize } = flags;
+    (0, validators_1.validateFileInput)(file);
+    const outFlag = target || out || '.';
+    const trixDir = path_1.default.join(outFlag, 'trix');
+    if (!fs_1.default.existsSync(trixDir)) {
+        fs_1.default.mkdirSync(trixDir);
+    }
+    const trackConfigs = (0, indexing_utils_1.prepareFileTrackConfigs)(file, fileId);
+    await (0, indexing_utils_1.indexDriver)({
+        trackConfigs,
+        outLocation: outFlag,
+        name: trackConfigs.length > 1 ? 'aggregate' : path_1.default.basename(file[0]),
+        quiet,
+        attributes: attributes.split(','),
+        typesToExclude: exclude.split(','),
+        assemblyNames: [],
+        prefixSize,
+    });
+    console.log('Successfully created index for these files. See https://jbrowse.org/storybook/lgv/main/?path=/story/text-searching--page for info about usage');
+}

package/dist/commands/text-index-utils/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexFileList = exports.perTrackIndex = exports.aggregateIndex = void 0;
+var aggregate_1 = require("./aggregate");
+Object.defineProperty(exports, "aggregateIndex", { enumerable: true, get: function () { return aggregate_1.aggregateIndex; } });
+var per_track_1 = require("./per-track");
+Object.defineProperty(exports, "perTrackIndex", { enumerable: true, get: function () { return per_track_1.perTrackIndex; } });
+var file_list_1 = require("./file-list");
+Object.defineProperty(exports, "indexFileList", { enumerable: true, get: function () { return file_list_1.indexFileList; } });

package/dist/commands/text-index-utils/indexing-utils.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runIxIxx = runIxIxx;
+exports.indexFiles = indexFiles;
+exports.indexDriver = indexDriver;
+exports.prepareFileTrackConfigs = prepareFileTrackConfigs;
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const ixixx_1 = require("ixixx");
+const adapter_utils_1 = require("./adapter-utils");
+const common_1 = require("../../types/common");
+const gff3Adapter_1 = require("../../types/gff3Adapter");
+const vcfAdapter_1 = require("../../types/vcfAdapter");
+async function runIxIxx({ readStream, outLocation, name, prefixSize, }) {
+    await (0, ixixx_1.ixIxxStream)(readStream, path_1.default.join(outLocation, 'trix', `${name}.ix`), path_1.default.join(outLocation, 'trix', `${name}.ixx`), prefixSize);
+}
+async function* indexFiles({ trackConfigs, attributes, outLocation, quiet, typesToExclude, }) {
+    for (const config of trackConfigs) {
+        const { adapter, textSearching } = config;
+        const { type } = adapter || {};
+        const { indexingFeatureTypesToExclude = typesToExclude, indexingAttributes = attributes, } = textSearching || {};
+        const loc = (0, adapter_utils_1.getAdapterLocation)(adapter);
+        if (!loc) {
+            continue;
+        }
+        if (type === 'Gff3TabixAdapter' || type === 'Gff3Adapter') {
+            yield* (0, gff3Adapter_1.indexGff3)({
+                config,
+                attributesToIndex: indexingAttributes,
+                inLocation: (0, adapter_utils_1.getLoc)(loc),
+                outLocation,
+                typesToExclude: indexingFeatureTypesToExclude,
+                quiet,
+            });
+        }
+        else if (type === 'VcfTabixAdapter' || type === 'VcfAdapter') {
+            yield* (0, vcfAdapter_1.indexVcf)({
+                config,
+                attributesToIndex: indexingAttributes,
+                inLocation: (0, adapter_utils_1.getLoc)(loc),
+                outLocation,
+                typesToExclude: indexingFeatureTypesToExclude,
+                quiet,
+            });
+        }
+    }
+}
+async function indexDriver({ trackConfigs, attributes, outLocation, name, quiet, typesToExclude, assemblyNames, prefixSize, }) {
+    const readStream = stream_1.Readable.from(indexFiles({
+        trackConfigs,
+        attributes,
+        outLocation,
+        quiet,
+        typesToExclude,
+    }));
+    await runIxIxx({
+        readStream,
+        outLocation,
+        name,
+        prefixSize: typeof prefixSize === 'string' ? parseInt(prefixSize) : prefixSize,
+    });
+    await (0, common_1.generateMeta)({
+        trackConfigs,
+        attributes,
+        outLocation,
+        name,
+        typesToExclude,
+        assemblyNames,
+    });
+}
+function prepareFileTrackConfigs(files, fileIds) {
+    const trackConfigs = files
+        .map(file => (0, common_1.guessAdapterFromFileName)(file))
+        .filter(fileConfig => (0, common_1.supported)(fileConfig.adapter?.type));
+    if (fileIds?.length) {
+        for (const [i, element] of fileIds.entries()) {
+            trackConfigs[i].trackId = element;
+        }
+    }
+    return trackConfigs;
+}

package/dist/commands/text-index-utils/per-track.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perTrackIndex = perTrackIndex;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const adapter_utils_1 = require("./adapter-utils");
+const config_utils_1 = require("./config-utils");
+const indexing_utils_1 = require("./indexing-utils");
+const validators_1 = require("./validators");
+async function perTrackIndex(flags) {
+    const { out, target, tracks, assemblies, attributes, quiet, force, exclude, prefixSize, } = flags;
+    const outFlag = target || out || '.';
+    const isDir = fs_1.default.lstatSync(outFlag).isDirectory();
+    const confFilePath = isDir ? path_1.default.join(outFlag, 'config.json') : outFlag;
+    const outLocation = path_1.default.dirname(confFilePath);
+    const config = (0, config_utils_1.readConf)(confFilePath);
+    const configTracks = config.tracks || [];
+    const trixDir = path_1.default.join(outLocation, 'trix');
+    if (!fs_1.default.existsSync(trixDir)) {
+        fs_1.default.mkdirSync(trixDir);
+    }
+    (0, validators_1.validateAssembliesForPerTrack)(assemblies);
+    const confs = (0, config_utils_1.getTrackConfigs)(confFilePath, tracks?.split(','));
+    if (!confs.length) {
+        throw new Error('Tracks not found in config.json, please add track configurations before indexing.');
+    }
+    for (const trackConfig of confs) {
+        const { textSearching, trackId, assemblyNames } = trackConfig;
+        if (textSearching?.textSearchAdapter && !force) {
+            console.log(`Note: ${trackId} has already been indexed with this configuration, use --force to overwrite this track. Skipping for now`);
+            continue;
+        }
+        console.log(`Indexing track ${trackId}...`);
+        await (0, indexing_utils_1.indexDriver)({
+            trackConfigs: [trackConfig],
+            attributes: attributes.split(','),
+            outLocation,
+            quiet,
+            name: trackId,
+            typesToExclude: exclude.split(','),
+            assemblyNames,
+            prefixSize,
+        });
+        if (!textSearching?.textSearchAdapter) {
+            // modifies track with new text search adapter
+            const index = configTracks.findIndex(track => trackId === track.trackId);
+            if (index !== -1) {
+                configTracks[index] = {
+                    ...trackConfig,
+                    textSearching: {
+                        ...textSearching,
+                        textSearchAdapter: (0, adapter_utils_1.createPerTrackTrixAdapter)(trackId, assemblyNames),
+                    },
+                };
+            }
+            else {
+                console.log("Error: can't find trackId");
+            }
+        }
+        (0, config_utils_1.writeConf)({ ...config, tracks: configTracks }, confFilePath);
+    }
+}

package/dist/commands/text-index-utils/validators.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTrackConfigs = validateTrackConfigs;
+exports.validateFileInput = validateFileInput;
+exports.validateAssembliesForPerTrack = validateAssembliesForPerTrack;
+function validateTrackConfigs(tracks) {
+    if (!tracks.length) {
+        throw new Error('Tracks not found in config.json, please add track configurations before indexing.');
+    }
+}
+function validateFileInput(file) {
+    if (!file) {
+        throw new Error('Cannot index file list without files');
+    }
+}
+function validateAssembliesForPerTrack(assemblies) {
+    if (assemblies) {
+        throw new Error(`Can't specify assemblies when indexing per track, remove assemblies flag to continue.`);
+    }
+}

package/dist/commands/text-index.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const index_1 = require("./text-index-utils/index");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+            description: 'Show CLI help',
+        },
+        tracks: {
+            type: 'string',
+            description: 'Specific tracks to index, formatted as comma separated trackIds. If unspecified, indexes all available tracks',
+        },
+        target: {
+            type: 'string',
+            description: 'Path to config file in JB2 installation directory to read from.',
+        },
+        out: { type: 'string', description: 'Synonym for target' },
+        attributes: {
+            type: 'string',
+            description: 'Comma separated list of attributes to index',
+            default: 'Name,ID',
+        },
+        assemblies: {
+            type: 'string',
+            short: 'a',
+            description: 'Specify the assembl(ies) to create an index for. If unspecified, creates an index for each assembly in the config',
+        },
+        force: {
+            type: 'boolean',
+            default: false,
+            description: 'Overwrite previously existing indexes',
+        },
+        quiet: {
+            type: 'boolean',
+            short: 'q',
+            default: false,
+            description: 'Hide the progress bars',
+        },
+        perTrack: {
+            type: 'boolean',
+            default: false,
+            description: 'If set, creates an index per track',
+        },
+        exclude: {
+            type: 'string',
+            description: 'Adds gene type to list of excluded types',
+            default: 'CDS,exon',
+        },
+        prefixSize: {
+            type: 'string',
+            description: 'Specify the prefix size for the ixx index. We attempt to automatically calculate this, but you can manually specify this too. If many genes have similar gene IDs e.g. Z000000001, Z000000002 the prefix size should be larger so that they get split into different bins',
+        },
+        file: {
+            type: 'string',
+            multiple: true,
+            description: 'File or files to index (can be used to create trix indexes for embedded component use cases not using a config.json for example)',
+        },
+        fileId: {
+            type: 'string',
+            multiple: true,
+            description: 'Set the trackId used for the indexes generated with the --file argument',
+        },
+        dryrun: {
+            type: 'boolean',
+            description: 'Just print out tracks that will be indexed by the process, without doing any indexing',
+        },
+    };
+    const { values: flags } = (0, util_1.parseArgs)({
+        args,
+        options,
+    });
+    const description = 'Make a text-indexing file for any given track(s).';
+    const examples = [
+        "# indexes all tracks that it can find in the current directory's config.json",
+        '$ jbrowse text-index',
+        '',
+        "# indexes specific trackIds that it can find in the current directory's config.json",
+        '$ jbrowse text-index --tracks=track1,track2,track3',
+        '',
+        "# indexes all tracks in a directory's config.json or in a specific config file",
+        '$ jbrowse text-index --out /path/to/jb2/',
+        '',
+        '# indexes only a specific assembly, and overwrite what was previously there using force (which is needed if a previous index already existed)',
+        '$ jbrowse text-index -a hg19 --force',
+        '',
+        '# create index for some files for use in @jbrowse/react-linear-genome-view2 or similar',
+        '$ jbrowse text-index --file myfile.gff3.gz --file myfile.vcfgz --out indexes',
+    ];
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse text-index [options]',
+            options,
+        });
+        return;
+    }
+    const { perTrack, file } = flags;
+    if (file) {
+        await (0, index_1.indexFileList)(flags);
+    }
+    else if (perTrack) {
+        await (0, index_1.perTrackIndex)(flags);
+    }
+    else {
+        await (0, index_1.aggregateIndex)(flags);
+    }
+}