@jbrowse/cli 3.6.0 → 3.6.1

package/dist/commands/add-track-utils/adapter-utils.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapterTypesToTrackTypeMap = void 0;
+exports.makeLocationProtocol = makeLocationProtocol;
+exports.guessFileNames = guessFileNames;
+exports.guessAdapter = guessAdapter;
+exports.guessTrackType = guessTrackType;
+function makeLocationProtocol(protocol) {
+    return (location) => {
+        if (protocol === 'uri') {
+            return {
+                uri: location,
+                locationType: 'UriLocation',
+            };
+        }
+        if (protocol === 'localPath') {
+            return {
+                localPath: location,
+                locationType: 'LocalPathLocation',
+            };
+        }
+        throw new Error(`invalid protocol ${protocol}`);
+    };
+}
+function guessFileNames({ location, index, bed1, bed2, }) {
+    if (/\.anchors(.simple)?$/i.test(location)) {
+        return {
+            file: location,
+            bed1: bed1,
+            bed2: bed2,
+        };
+    }
+    else if (/\.bam$/i.test(location)) {
+        return {
+            file: location,
+            index: index || `${location}.bai`,
+        };
+    }
+    else if (/\.cram$/i.test(location)) {
+        return {
+            file: location,
+            index: index || `${location}.crai`,
+        };
+    }
+    else if (/\.gff3?\.b?gz$/i.test(location) ||
+        /\.vcf\.b?gz$/i.test(location) ||
+        /\.bed\.b?gz$/i.test(location) ||
+        /\.pif\.b?gz$/i.test(location)) {
+        return {
+            file: location,
+            index: index || `${location}.tbi`,
+        };
+    }
+    else if (/\.(fa|fasta|fas|fna|mfa)$/i.test(location)) {
+        return {
+            file: location,
+            index: index || `${location}.fai`,
+        };
+    }
+    else if (/\.(fa|fasta|fas|fna|mfa)\.b?gz$/i.test(location)) {
+        return {
+            file: location,
+            index: `${location}.fai`,
+            index2: `${location}.gzi`,
+        };
+    }
+    else if (/\.2bit$/i.test(location) ||
+        /\.bedpe(\.gz)?$/i.test(location) ||
+        /\/trackData.jsonz?$/i.test(location) ||
+        /\/sparql$/i.test(location) ||
+        /\.out(\.gz)?$/i.test(location) ||
+        /\.paf(\.gz)?$/i.test(location) ||
+        /\.delta(\.gz)?$/i.test(location) ||
+        /\.bed?$/i.test(location) ||
+        /\.(bw|bigwig)$/i.test(location) ||
+        /\.(bb|bigbed)$/i.test(location) ||
+        /\.vcf$/i.test(location) ||
+        /\.gtf?$/i.test(location) ||
+        /\.gff3?$/i.test(location) ||
+        /\.chain(\.gz)?$/i.test(location) ||
+        /\.hic$/i.test(location)) {
+        return {
+            file: location,
+        };
+    }
+    return {};
+}
+function guessAdapter({ location, protocol, index, bed1, bed2, }) {
+    const makeLocation = makeLocationProtocol(protocol);
+    if (/\.bam$/i.test(location)) {
+        return {
+            type: 'BamAdapter',
+            bamLocation: makeLocation(location),
+            index: {
+                location: makeLocation(index || `${location}.bai`),
+                indexType: index?.toUpperCase().endsWith('CSI') ? 'CSI' : 'BAI',
+            },
+        };
+    }
+    else if (/\.cram$/i.test(location)) {
+        return {
+            type: 'CramAdapter',
+            cramLocation: makeLocation(location),
+            craiLocation: makeLocation(`${location}.crai`),
+        };
+    }
+    else if (/\.gff3?$/i.test(location)) {
+        return {
+            type: 'Gff3Adapter',
+            gffLocation: makeLocation(location),
+        };
+    }
+    else if (/\.gff3?\.b?gz$/i.test(location)) {
+        return {
+            type: 'Gff3TabixAdapter',
+            gffGzLocation: makeLocation(location),
+            index: {
+                location: makeLocation(index || `${location}.tbi`),
+                indexType: index?.toUpperCase().endsWith('CSI') ? 'CSI' : 'TBI',
+            },
+        };
+    }
+    else if (/\.gtf?$/i.test(location)) {
+        return {
+            type: 'GtfAdapter',
+            gtfLocation: makeLocation(location),
+        };
+    }
+    else if (/\.vcf$/i.test(location)) {
+        return {
+            type: 'VcfAdapter',
+            vcfLocation: makeLocation(location),
+        };
+    }
+    else if (/\.vcf\.b?gz$/i.test(location)) {
+        return {
+            type: 'VcfTabixAdapter',
+            vcfGzLocation: makeLocation(location),
+            index: {
+                location: makeLocation(index || `${location}.tbi`),
+                indexType: index?.toUpperCase().endsWith('CSI') ? 'CSI' : 'TBI',
+            },
+        };
+    }
+    else if (/\.vcf\.idx$/i.test(location)) {
+        return {
+            type: 'UNSUPPORTED',
+        };
+    }
+    else if (/\.bedpe(.gz)?$/i.test(location)) {
+        return {
+            type: 'BedpeAdapter',
+            bedpeLocation: makeLocation(location),
+        };
+    }
+    else if (/\.bed$/i.test(location)) {
+        return {
+            type: 'BedAdapter',
+            bedLocation: makeLocation(location),
+        };
+    }
+    else if (/\.pif\.b?gz$/i.test(location)) {
+        return {
+            type: 'PairwiseIndexedPAFAdapter',
+            pifGzLocation: makeLocation(location),
+            index: {
+                location: makeLocation(index || `${location}.tbi`),
+                indexType: index?.toUpperCase().endsWith('CSI') ? 'CSI' : 'TBI',
+            },
+        };
+    }
+    else if (/\.bed\.b?gz$/i.test(location)) {
+        return {
+            type: 'BedTabixAdapter',
+            bedGzLocation: makeLocation(location),
+            index: {
+                location: makeLocation(index || `${location}.tbi`),
+                indexType: index?.toUpperCase().endsWith('CSI') ? 'CSI' : 'TBI',
+            },
+        };
+    }
+    else if (/\.(bb|bigbed)$/i.test(location)) {
+        return {
+            type: 'BigBedAdapter',
+            bigBedLocation: makeLocation(location),
+        };
+    }
+    else if (/\.(bw|bigwig)$/i.test(location)) {
+        return {
+            type: 'BigWigAdapter',
+            bigWigLocation: makeLocation(location),
+        };
+    }
+    else if (/\.(fa|fasta|fna|mfa)$/i.test(location)) {
+        return {
+            type: 'IndexedFastaAdapter',
+            fastaLocation: makeLocation(location),
+            faiLocation: makeLocation(index || `${location}.fai`),
+        };
+    }
+    else if (/\.(fa|fasta|fna|mfa)\.b?gz$/i.test(location)) {
+        return {
+            type: 'BgzipFastaAdapter',
+            fastaLocation: makeLocation(location),
+            faiLocation: makeLocation(`${location}.fai`),
+            gziLocation: makeLocation(`${location}.gzi`),
+        };
+    }
+    else if (/\.2bit$/i.test(location)) {
+        return {
+            type: 'TwoBitAdapter',
+            twoBitLocation: makeLocation(location),
+        };
+    }
+    else if (/\.sizes$/i.test(location)) {
+        return {
+            type: 'UNSUPPORTED',
+        };
+    }
+    else if (/\/trackData.jsonz?$/i.test(location)) {
+        return {
+            type: 'NCListAdapter',
+            rootUrlTemplate: makeLocation(location),
+        };
+    }
+    else if (/\/sparql$/i.test(location)) {
+        return {
+            type: 'SPARQLAdapter',
+            endpoint: location,
+        };
+    }
+    else if (/\.hic$/i.test(location)) {
+        return {
+            type: 'HicAdapter',
+            hicLocation: makeLocation(location),
+        };
+    }
+    else if (/\.paf(.gz)?$/i.test(location)) {
+        return {
+            type: 'PAFAdapter',
+            pafLocation: makeLocation(location),
+        };
+    }
+    else if (/\.out(.gz)?$/i.test(location)) {
+        return {
+            type: 'MashMapAdapter',
+            outLocation: makeLocation(location),
+        };
+    }
+    else if (/\.chain(.gz)?$/i.test(location)) {
+        return {
+            type: 'ChainAdapter',
+            chainLocation: makeLocation(location),
+        };
+    }
+    else if (/\.delta(.gz)?$/i.test(location)) {
+        return {
+            type: 'DeltaAdapter',
+            deltaLocation: makeLocation(location),
+        };
+    }
+    else if (/\.anchors(.gz)?$/i.test(location)) {
+        return {
+            type: 'MCScanAnchorsAdapter',
+            mcscanAnchorsLocation: makeLocation(location),
+            bed1Location: bed1 ? makeLocation(bed1) : undefined,
+            bed2Location: bed2 ? makeLocation(bed2) : undefined,
+        };
+    }
+    else if (/\.anchors.simple(.gz)?$/i.test(location)) {
+        return {
+            type: 'MCScanSimpleAnchorsAdapter',
+            mcscanSimpleAnchorsLocation: makeLocation(location),
+            bed1Location: bed1 ? makeLocation(bed1) : undefined,
+            bed2Location: bed2 ? makeLocation(bed2) : undefined,
+        };
+    }
+    return {
+        type: 'UNKNOWN',
+    };
+}
+exports.adapterTypesToTrackTypeMap = {
+    BamAdapter: 'AlignmentsTrack',
+    CramAdapter: 'AlignmentsTrack',
+    BgzipFastaAdapter: 'ReferenceSequenceTrack',
+    BigWigAdapter: 'QuantitativeTrack',
+    IndexedFastaAdapter: 'ReferenceSequenceTrack',
+    TwoBitAdapter: 'ReferenceSequenceTrack',
+    VcfTabixAdapter: 'VariantTrack',
+    VcfAdapter: 'VariantTrack',
+    BedpeAdapter: 'VariantTrack',
+    BedAdapter: 'FeatureTrack',
+    HicAdapter: 'HicTrack',
+    PAFAdapter: 'SyntenyTrack',
+    DeltaAdapter: 'SyntenyTrack',
+    ChainAdapter: 'SyntenyTrack',
+    MashMapAdapter: 'SyntenyTrack',
+    PairwiseIndexedPAFAdapter: 'SyntenyTrack',
+    MCScanAnchorsAdapter: 'SyntenyTrack',
+    MCScanSimpleAnchorsAdapter: 'SyntenyTrack',
+};
+function guessTrackType(adapterType) {
+    return exports.adapterTypesToTrackTypeMap[adapterType] || 'FeatureTrack';
+}

package/dist/commands/add-track-utils/file-operations.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFile = loadFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const { copyFile, rename, symlink, unlink } = fs_1.default.promises;
+const { COPYFILE_EXCL } = fs_1.default.constants;
+async function loadFile({ src, destDir, mode, subDir = '', force = false, }) {
+    if (mode === 'inPlace') {
+        return;
+    }
+    const dest = path_1.default.join(destDir, subDir, path_1.default.basename(src));
+    if (force) {
+        try {
+            await unlink(dest);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT') {
+                throw e;
+            }
+        }
+    }
+    if (mode === 'copy') {
+        return copyFile(src, dest, force ? 0 : COPYFILE_EXCL);
+    }
+    if (mode === 'move') {
+        return rename(src, dest);
+    }
+    if (mode === 'symlink') {
+        return symlink(path_1.default.resolve(src), dest);
+    }
+    return undefined;
+}

package/dist/commands/add-track-utils/track-config.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapLocationForFiles = mapLocationForFiles;
+exports.buildTrackConfig = buildTrackConfig;
+exports.addSyntenyAssemblyNames = addSyntenyAssemblyNames;
+const path_1 = __importDefault(require("path"));
+const json_parse_better_errors_1 = __importDefault(require("json-parse-better-errors"));
+const validators_1 = require("./validators");
+const SYNTENY_ADAPTERS = new Set([
+    'PAFAdapter',
+    'PairwiseIndexedPAFAdapter',
+    'DeltaAdapter',
+    'ChainAdapter',
+    'MashMapAdapter',
+    'MCScanAnchorsAdapter',
+    'MCScanSimpleAnchorsAdapter',
+]);
+function mapLocationForFiles(p, load, subDir) {
+    return !p || (0, validators_1.isUrl)(p) || load === 'inPlace'
+        ? p
+        : path_1.default.join(subDir || '', path_1.default.basename(p));
+}
+function buildTrackConfig({ location, trackType, trackId, name, assemblyNames, category, description, config, adapter, configContents, skipCheck, }) {
+    const configObj = config ? (0, json_parse_better_errors_1.default)(config) : {};
+    const finalTrackId = trackId || path_1.default.basename(location, path_1.default.extname(location));
+    const finalName = name || finalTrackId;
+    const finalAssemblyNames = assemblyNames || configContents.assemblies?.[0]?.name || '';
+    const trackConfig = {
+        type: trackType,
+        trackId: finalTrackId,
+        name: finalName,
+        adapter,
+        category: category?.split(',').map(c => c.trim()),
+        assemblyNames: finalAssemblyNames.split(',').map(a => a.trim()),
+        description,
+        ...configObj,
+    };
+    // Special handling for AlignmentsTrack
+    if (trackType === 'AlignmentsTrack') {
+        const assembly = configContents.assemblies?.find(asm => asm.name === finalAssemblyNames);
+        if (assembly) {
+            // @ts-expect-error
+            trackConfig.adapter.sequenceAdapter = assembly.sequence.adapter;
+        }
+        else if (!skipCheck) {
+            console.error(`Error: Failed to find assemblyName ${finalAssemblyNames}`);
+            process.exit(1);
+        }
+    }
+    return trackConfig;
+}
+function addSyntenyAssemblyNames(adapter, assemblyNames) {
+    if (SYNTENY_ADAPTERS.has(adapter.type)) {
+        return {
+            ...adapter,
+            assemblyNames: assemblyNames?.split(',').map(a => a.trim()),
+        };
+    }
+    return adapter;
+}

package/dist/commands/add-track-utils/validators.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUrl = void 0;
+exports.validateLoadOption = validateLoadOption;
+exports.validateTrackArg = validateTrackArg;
+exports.validateLoadAndLocation = validateLoadAndLocation;
+exports.validateAdapterType = validateAdapterType;
+exports.validateAssemblies = validateAssemblies;
+exports.validateTrackId = validateTrackId;
+exports.createTargetDirectory = createTargetDirectory;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const isUrl = (loc) => loc?.match(/^https?:\/\//);
+exports.isUrl = isUrl;
+function validateLoadOption(load) {
+    if (load && !['copy', 'symlink', 'move', 'inPlace'].includes(load)) {
+        throw new Error('Error: --load must be one of: copy, symlink, move, inPlace');
+    }
+}
+function validateTrackArg(track) {
+    if (!track) {
+        console.error('Missing 1 required arg:');
+        console.error('track  Track file or URL');
+        console.error('See more help with --help');
+        process.exit(1);
+    }
+}
+function validateLoadAndLocation(location, load) {
+    if (isUrl(location) && load) {
+        throw new Error('The --load flag is used for local files only, but a URL was provided');
+    }
+    else if (!isUrl(location) && !load) {
+        throw new Error(`The --load flag should be used if a local file is used, example --load
+        copy to copy the file into the config directory. Options for load are
+        copy/move/symlink/inPlace (inPlace for no file operations)`);
+    }
+}
+function validateAdapterType(adapterType) {
+    if (adapterType === 'UNKNOWN') {
+        throw new Error('Track type is not recognized');
+    }
+    if (adapterType === 'UNSUPPORTED') {
+        throw new Error('Track type is not supported');
+    }
+}
+function validateAssemblies(configContents, assemblyNames) {
+    if (!configContents.assemblies?.length) {
+        throw new Error('No assemblies found. Please add one before adding tracks');
+    }
+    if (configContents.assemblies.length > 1 && !assemblyNames) {
+        throw new Error('Too many assemblies, cannot default to one. Please specify the assembly with the --assemblyNames flag');
+    }
+}
+function validateTrackId(configContents, trackId, force, overwrite) {
+    if (!configContents.tracks) {
+        configContents.tracks = [];
+    }
+    const idx = configContents.tracks.findIndex(c => c.trackId === trackId);
+    if (idx !== -1 && !force && !overwrite) {
+        throw new Error(`Cannot add track with id ${trackId}, a track with that id already exists (use --force to override)`);
+    }
+    return idx;
+}
+function createTargetDirectory(configDir, subDir) {
+    if (subDir) {
+        const dir = path_1.default.join(configDir, subDir);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir);
+        }
+    }
+}

package/dist/commands/add-track.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const adapter_utils_1 = require("./add-track-utils/adapter-utils");
+const track_config_1 = require("./add-track-utils/track-config");
+const validators_1 = require("./add-track-utils/validators");
+const track_utils_1 = require("./track-utils");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+        trackType: {
+            type: 'string',
+            short: 't',
+            description: 'Type of track, by default inferred from track file',
+        },
+        name: {
+            type: 'string',
+            short: 'n',
+            description: 'Name of the track. Will be defaulted to the trackId if none specified',
+        },
+        indexFile: {
+            type: 'string',
+            description: 'Optional index file for the track',
+        },
+        description: {
+            type: 'string',
+            short: 'd',
+            description: 'Optional description of the track',
+        },
+        assemblyNames: {
+            type: 'string',
+            short: 'a',
+            description: 'Assembly name or names for track as comma separated string',
+        },
+        category: {
+            type: 'string',
+            description: 'Optional comma separated string of categories to group tracks',
+        },
+        config: {
+            type: 'string',
+            description: 'Any extra config settings to add to a track',
+        },
+        target: {
+            type: 'string',
+            description: 'Path to config file in JB2 installation to write out to',
+        },
+        out: {
+            type: 'string',
+            description: 'Synonym for target',
+        },
+        subDir: {
+            type: 'string',
+            description: 'When using --load a file, output to a subdirectory of the target dir',
+        },
+        trackId: {
+            type: 'string',
+            description: 'trackId for the track, by default inferred from filename',
+        },
+        load: {
+            type: 'string',
+            short: 'l',
+            description: 'How to manage the track (copy, symlink, move, inPlace)',
+        },
+        skipCheck: {
+            type: 'boolean',
+            description: 'Skip check for whether file or URL exists',
+        },
+        overwrite: {
+            type: 'boolean',
+            description: 'Overwrites existing track if it shares the same trackId',
+        },
+        force: {
+            type: 'boolean',
+            short: 'f',
+            description: 'Equivalent to --skipCheck --overwrite',
+        },
+        protocol: {
+            type: 'string',
+            description: 'Force protocol to a specific value',
+        },
+        bed1: {
+            type: 'string',
+            description: 'Used only for mcscan anchors/simpleAnchors types',
+        },
+        bed2: {
+            type: 'string',
+            description: 'Used only for mcscan anchors/simpleAnchors types',
+        },
+    };
+    const { values: flags, positionals } = (0, util_1.parseArgs)({
+        args,
+        options,
+        allowPositionals: true,
+    });
+    const description = 'Add a track to a JBrowse 2 configuration';
+    const examples = [
+        '# copy /path/to/my.bam and /path/to/my.bam.bai to current directory and adds track to config.json',
+        '$ jbrowse add-track /path/to/my.bam --load copy',
+        '',
+        '# copy my.bam and my.bam.bai to /path/to/jb2/bam and adds track entry to /path/to/jb2/bam/config.json',
+        '$ jbrowse add-track my.bam --load copy --out /path/to/jb2 --subDir bam',
+        '',
+        '# same as above, but specify path to bai file. needed for if the bai file does not have the extension .bam.bai',
+        '$ jbrowse add-track my.bam --indexFile my.bai --load copy',
+        '',
+        '# creates symlink for /path/to/my.bam and adds track to config.json',
+        '$ jbrowse add-track /path/to/my.bam --load symlink',
+        '',
+        '# add track from URL to config.json, no --load flag needed',
+        '$ jbrowse add-track https://mywebsite.com/my.bam',
+        '',
+        '# --load inPlace adds a track without doing file operations',
+        '$ jbrowse add-track /url/relative/path.bam --load inPlace',
+    ];
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse add-track <track> [options]',
+            options,
+        });
+        return;
+    }
+    (0, validators_1.validateLoadOption)(flags.load);
+    const track = positionals[0];
+    (0, validators_1.validateTrackArg)(track);
+    const { config, skipCheck, force, overwrite, category, description: trackDescription, load, subDir = '', target, protocol = 'uri', out, indexFile: index, bed1, bed2, } = flags;
+    const output = target || out || '.';
+    const targetConfigPath = (0, track_utils_1.resolveTrackConfigPath)(output);
+    const configDir = path_1.default.dirname(targetConfigPath);
+    (0, validators_1.createTargetDirectory)(configDir, subDir);
+    const location = track;
+    const mapLoc = (p) => (0, track_config_1.mapLocationForFiles)(p, load, subDir);
+    let adapter = (0, adapter_utils_1.guessAdapter)({
+        protocol,
+        location: mapLoc(location),
+        index: index ? mapLoc(index) : undefined,
+        bed1: bed1 ? mapLoc(bed1) : undefined,
+        bed2: bed2 ? mapLoc(bed2) : undefined,
+    });
+    adapter = (0, track_config_1.addSyntenyAssemblyNames)(adapter, flags.assemblyNames);
+    (0, validators_1.validateLoadAndLocation)(location, load);
+    (0, validators_1.validateAdapterType)(adapter.type);
+    const configContents = await (0, track_utils_1.loadTrackConfig)(targetConfigPath);
+    (0, validators_1.validateAssemblies)(configContents, flags.assemblyNames);
+    const trackParams = (0, track_utils_1.buildTrackParams)({
+        flags,
+        location,
+        adapter,
+        configContents,
+    });
+    const trackConfig = (0, track_utils_1.createTrackConfiguration)({
+        location,
+        trackParams,
+        flags: { category, description: trackDescription, config },
+        adapter,
+        configContents,
+        skipCheck,
+    });
+    const { updatedConfig, wasOverwritten } = (0, track_utils_1.addTrackToConfig)({
+        configContents,
+        trackConfig,
+        trackId: trackParams.trackId,
+        force,
+        overwrite,
+    });
+    await (0, track_utils_1.processTrackFiles)({
+        location,
+        index,
+        bed1,
+        bed2,
+        load,
+        configDir,
+        subDir,
+        force,
+    });
+    await (0, track_utils_1.saveTrackConfigAndReport)({
+        config: updatedConfig,
+        targetConfigPath,
+        name: trackParams.name,
+        trackId: trackParams.trackId,
+        wasOverwritten,
+    });
+}