@prosopo/datasets-fs 0.1.17 → 0.1.19

package/src/generate/distinct/generate.ts

@@ -1,238 +0,0 @@
-import { Args } from './args.js'
-import {
-    CaptchaTypes,
-    CaptchaWithoutId,
-    Captchas,
-    CaptchasContainerSchema,
-    DataSchema,
-    Item,
-    LabelledDataSchema,
-    LabelledItem,
-    LabelsContainerSchema,
-    RawSolution,
-} from '@prosopo/types'
-import { Logger, ProsopoEnvError, getLoggerDefault } from '@prosopo/common'
-import { blake2AsHex } from '@polkadot/util-crypto'
-import { checkDuplicates } from '../util.js'
-import { lodash, setSeedGlobal } from '@prosopo/util'
-import bcrypt from 'bcrypt'
-import cliProgress from 'cli-progress'
-import fs from 'fs'
-
-export default async (args: Args, logger?: Logger) => {
-    logger = logger || getLoggerDefault()
-
-    logger.debug(args, 'generating...')
-
-    const outFile: string = args.out
-    const overwrite = args.overwrite || false
-    if (!overwrite && fs.existsSync(outFile)) {
-        throw new ProsopoEnvError(new Error(`output file already exists: ${outFile}`), 'FS.FILE_ALREADY_EXISTS')
-    }
-    const labelledMapFile: string | undefined = args.labelled
-    if (labelledMapFile && !fs.existsSync(labelledMapFile)) {
-        throw new ProsopoEnvError(
-            new Error(`labelled map file does not exist: ${labelledMapFile}`),
-            'FS.FILE_NOT_FOUND'
-        )
-    }
-    const unlabelledMapFile: string | undefined = args.unlabelled
-    if (unlabelledMapFile && !fs.existsSync(unlabelledMapFile)) {
-        throw new ProsopoEnvError(
-            new Error(`unlabelled map file does not exist: ${unlabelledMapFile}`),
-            'FS.FILE_NOT_FOUND'
-        )
-    }
-    const labelsFile: string | undefined = args.labels
-    const seed: number = args.seed || 0
-    const size: number = args.size || 9
-    const minCorrect: number = args.minCorrect || 1
-    const maxCorrect: number = args.maxCorrect || size - 1
-    const solved: number = args.solved || 0
-    const unsolved: number = args.unsolved || 0
-    const saltRounds = 10
-    const allowDuplicatesLabelled = args.allowDuplicatesLabelled || args.allowDuplicates || false
-    const allowDuplicatesUnlabelled = args.allowDuplicatesUnlabelled || args.allowDuplicates || false
-
-    // set the seed
-    setSeedGlobal(seed)
-    // get lodash (with seeded rng)
-    const _ = lodash()
-
-    // load the map to get the labelled and unlabelled data
-    const labelled: LabelledItem[] = labelledMapFile
-        ? LabelledDataSchema.parse(JSON.parse(fs.readFileSync(labelledMapFile, 'utf8'))).items
-        : []
-    const unlabelled: Item[] = unlabelledMapFile
-        ? DataSchema.parse(JSON.parse(fs.readFileSync(unlabelledMapFile, 'utf8'))).items
-        : []
-
-    // check for duplicates
-    checkDuplicates(labelled, unlabelled, {
-        allowDuplicatesLabelled,
-        allowDuplicatesUnlabelled,
-    })
-
-    // split the labelled data by label
-    const labelToImages: { [label: string]: Item[] } = {}
-    for (const entry of labelled) {
-        labelToImages[entry.label] = labelToImages[entry.label] || []
-        labelToImages[entry.label].push(entry)
-    }
-    const targets = Object.keys(labelToImages)
-
-    // load the labels from file
-    // these are the labels that unlabelled data will be assigned to
-    // note that these can be different to the labels in the map file as the labelled data is independent of the unlabelled data in terms of labels
-    const labels: string[] = []
-    if (labelsFile && fs.existsSync(labelsFile)) {
-        labels.push(...[...LabelsContainerSchema.parse(JSON.parse(fs.readFileSync(labelsFile, 'utf8'))).labels])
-    } else {
-        // else default to the labels in the labelled data
-        labels.push(...[...targets])
-    }
-
-    // generate n solved captchas
-    const solvedCaptchas: CaptchaWithoutId[] = []
-    // create a new progress bar instance and use shades_classic theme
-    const barSolved = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic)
-
-    logger.info(`Generating ${solved} solved captchas...`)
-    barSolved.start(solved, 0)
-    for (let i = 0; i < solved; i++) {
-        // update the current value in your application..
-        barSolved.update(i + 1)
-
-        if (targets.length <= 1) {
-            throw new ProsopoEnvError(
-                new Error(`not enough different labels in labelled data: ${labelledMapFile}`),
-                'DATASET.NOT_ENOUGH_LABELS'
-            )
-        }
-
-        // uniformly sample targets
-        const target = targets[i % targets.length]
-        const notTargets = targets.filter((t) => t !== target)
-
-        // how many correct items should be in the captcha?
-        const nCorrect = _.random(minCorrect, maxCorrect)
-        // how many incorrect items should be in the captcha?
-        const nIncorrect = size - nCorrect
-
-        const targetItems: Item[] = labelToImages[target]
-        const notTargetItems: Item[] = notTargets.map((notTarget) => labelToImages[notTarget]).flat()
-
-        if (targetItems.length < nCorrect) {
-            throw new ProsopoEnvError(
-                new Error(`not enough images for target (${target})`),
-                'DATASET.NOT_ENOUGH_IMAGES'
-            )
-        }
-        if (notTargetItems.length < nIncorrect) {
-            throw new ProsopoEnvError(
-                new Error(`not enough non-matching images for target (${target})`),
-                'DATASET.NOT_ENOUGH_IMAGES'
-            )
-        }
-
-        // get the correct items
-        const correctItems: Item[] = _.sampleSize(targetItems, nCorrect)
-
-        // get the incorrect items
-        const incorrectItems: Item[] = _.sampleSize(notTargetItems, nIncorrect)
-
-        let items: Item[] = [...correctItems, ...incorrectItems]
-        let indices: number[] = [...Array(items.length).keys()]
-        indices = _.shuffle(indices)
-        items = indices.map((i) => items[i])
-        items = items.map((item) => {
-            return {
-                data: item.data,
-                hash: item.hash,
-                type: item.type,
-            }
-        })
-
-        // the first n indices are the correct items
-        const solution: RawSolution[] = indices
-            .map((index, i) => {
-                return {
-                    pre: index, // the index of the item in the items array before shuffle
-                    post: i, // the index of the item in the shuffled array
-                }
-            })
-            .filter((item) => item.pre < correctItems.length) // keep all items that were in the first n slots of the original item array - these were the correct items
-            .map((item) => {
-                return item.post // return the index in the shuffled array
-            })
-
-        const salt = blake2AsHex(bcrypt.genSaltSync(saltRounds))
-        // create the captcha
-        const captcha: CaptchaWithoutId = {
-            salt,
-            target,
-            items,
-            solution,
-        }
-        solvedCaptchas.push(captcha)
-    }
-    barSolved.stop()
-    logger.info(`Generating ${unsolved} unsolved captchas...`)
-    // create a new progress bar instance and use shades_classic theme
-    const barUnsolved = new cliProgress.SingleBar({}, cliProgress.Presets.shades_classic)
-    barUnsolved.start(unsolved, 0)
-    // generate n unsolved captchas
-    const unsolvedCaptchas: CaptchaWithoutId[] = []
-    for (let i = 0; i < unsolved; i++) {
-        barUnsolved.update(i + 1)
-        if (unlabelled.length <= size) {
-            throw new ProsopoEnvError(
-                new Error(`unlabelled map file does not contain enough data: ${unlabelledMapFile}`),
-                'DATASET.NOT_ENOUGH_IMAGES'
-            )
-        }
-        // pick a random label to be the target
-        // note that these are potentially different to the labelled data labels
-        if (labels.length <= 0) {
-            throw new ProsopoEnvError(
-                new Error(`no labels found for unlabelled data: ${labelsFile}`),
-                'DATASET.NOT_ENOUGH_LABELS'
-            )
-        }
-        const index = _.random(0, labels.length - 1)
-        const target = labels[index]
-        // randomly pick images from the unlabelled data
-        const itemSet: Item[] = _.sampleSize(unlabelled, size)
-        // shuffle the items
-        let items: Item[] = [...itemSet]
-        let indices: number[] = [...Array(items.length).keys()]
-        indices = _.shuffle(indices)
-        items = indices.map((i) => items[i])
-        items = items.map((item) => {
-            return {
-                data: item.data,
-                hash: item.hash,
-                type: item.type,
-            }
-        })
-        const salt = blake2AsHex(bcrypt.genSaltSync(saltRounds))
-        // create the captcha
-        const captcha: CaptchaWithoutId = {
-            salt,
-            target,
-            items,
-        }
-        unsolvedCaptchas.push(captcha)
-    }
-    barUnsolved.stop()
-    // write to file
-    const output: Captchas = {
-        captchas: [...solvedCaptchas, ...unsolvedCaptchas],
-        format: CaptchaTypes.SelectAll,
-    }
-
-    // verify the output
-    CaptchasContainerSchema.parse(output)
-
-    fs.writeFileSync(outFile, JSON.stringify(output, null, 4))
-}

package/src/generate/distinct/index.ts

@@ -1,3 +0,0 @@
-export * from './generate.js'
-export * from './cli.js'
-export * from './args.js'

package/src/generate/index.ts

@@ -1,4 +0,0 @@
-export * as distinct from './distinct/index.js'
-export * as union from './union/index.js'
-export * from './cli.js'
-export * from './args.js'

package/src/generate/union/args.ts

@@ -1,14 +0,0 @@
-import { argsSchema as parentSchema } from '../args.js'
-// Args for generating a dataset
-
-import { z } from 'zod'
-
-export const argsSchema = parentSchema.extend({
-    minCorrect: z.number().optional(),
-    minIncorrect: z.number().optional(),
-    minLabelled: z.number().optional(),
-    maxLabelled: z.number().optional(),
-    count: z.number().optional(),
-})
-
-export type Args = z.infer<typeof argsSchema>

package/src/generate/union/cli.ts

@@ -1,38 +0,0 @@
-import { ArgumentsCamelCase, Argv } from 'yargs'
-import { Logger } from '@prosopo/common'
-import { argsSchema } from './args.js'
-import generate from './generate.js'
-
-export default (cmdArgs?: { logger?: Logger }) => {
-    return {
-        command: 'union',
-        describe:
-            'Generate distinct captchas producing captcha challenges comprising one or more rounds, mixing labelled and unlabelled data into a single round',
-        builder: (yargs: Argv) => {
-            return yargs
-                .option('count', {
-                    type: 'number',
-                    description: 'Number of captchas to generate',
-                })
-                .option('min-correct', {
-                    type: 'number',
-                    description: 'Minimum number of target images in each captcha',
-                })
-                .option('min-incorrect', {
-                    type: 'number',
-                    description: 'Minimum number of incorrect images in each captcha',
-                })
-                .option('min-labelled', {
-                    type: 'number',
-                    description: 'Minimum number of labelled images in each captcha',
-                })
-                .option('max-labelled', {
-                    type: 'number',
-                    description: 'Maximum number of labelled images in each captcha',
-                })
-        },
-        handler: async (argv: ArgumentsCamelCase) => {
-            await generate(argsSchema.parse(argv), cmdArgs?.logger)
-        },
-    }
-}

package/src/generate/union/generate.ts

@@ -1,210 +0,0 @@
-import { Args } from './args.js'
-import {
-    CaptchaTypes,
-    CaptchaWithoutId,
-    Captchas,
-    CaptchasContainerSchema,
-    DataSchema,
-    Item,
-    LabelledDataSchema,
-    LabelledItem,
-    LabelsContainerSchema,
-    RawSolution,
-} from '@prosopo/types'
-import { Logger, ProsopoEnvError, getLoggerDefault } from '@prosopo/common'
-import { blake2AsHex } from '@polkadot/util-crypto'
-import { checkDuplicates } from '../util.js'
-import { lodash, setSeedGlobal } from '@prosopo/util'
-import bcrypt from 'bcrypt'
-import fs from 'fs'
-
-export default async (args: Args, logger?: Logger) => {
-    logger = logger || getLoggerDefault()
-
-    logger.debug(args, 'generating...')
-
-    const outFile: string = args.out
-    const overwrite = args.overwrite || false
-    if (!overwrite && fs.existsSync(outFile)) {
-        throw new ProsopoEnvError(new Error(`Output file already exists: ${outFile}`), 'FS.FILE_ALREADY_EXISTS')
-    }
-    const labelledMapFile: string | undefined = args.labelled
-    if (labelledMapFile && !fs.existsSync(labelledMapFile)) {
-        throw new ProsopoEnvError(
-            new Error(`Labelled map file does not exist: ${labelledMapFile}`),
-            'FS.FILE_NOT_FOUND'
-        )
-    }
-    const unlabelledMapFile: string | undefined = args.unlabelled
-    if (unlabelledMapFile && !fs.existsSync(unlabelledMapFile)) {
-        throw new ProsopoEnvError(
-            new Error(`Unlabelled map file does not exist: ${unlabelledMapFile}`),
-            'FS.FILE_NOT_FOUND'
-        )
-    }
-    const labelsFile: string | undefined = args.labels
-    const seed: number = args.seed || 0
-    const size: number = args.size || 9
-    const minCorrect: number = args.minCorrect || 1
-    const saltRounds = 10
-    const allowDuplicatesLabelled = args.allowDuplicatesLabelled || args.allowDuplicates || false
-    const allowDuplicatesUnlabelled = args.allowDuplicatesUnlabelled || args.allowDuplicates || false
-    const minIncorrect: number = Math.max(args.minIncorrect || 1, 1) // at least 1 incorrect image
-    const minLabelled: number = minCorrect + minIncorrect // min incorrect + correct
-    const maxLabelled: number = Math.min(args.maxLabelled || size, size) // at least 1 labelled image
-    const count: number = args.count || 0
-
-    // set the seed
-    setSeedGlobal(seed)
-    // get lodash (with seeded rng)
-    const _ = lodash()
-
-    // the captcha contains n images. Each of these images are either labelled, being correct or incorrect against the target, or unlabelled. To construct one of these captchas, we need to decide how many of the images should be labelled vs unlabelled, and then how many of the labelled images should be correct vs incorrect
-    // in the traditional captcha, two rounds are produced, one with labelled images and the other with unlabelled images. This gives 18 images overall, 9 labels produced.
-    // the parameters for generation can regulate how many labels are collected vs how much of a test the captcha posses. E.g. 18 images could have 16 unlabelled and 2 labelled, or 2 unlabelled and 16 labelled. The former is a better test of the user being human, but the latter is a better for maximising label collection.
-    // if we focus on a single captcha round of 9 images, we must have at least 1 labelled correct image in the captcha for it to work, otherwise it's just a labelling phase, which normally isn't a problem but if we're treating these as tests for humanity too then we need some kind of test in there. (e.g. we abolish the labelled then unlabelled pattern of the challenge rounds in favour of mixing labelled and unlabelled data, but we then run a small chance of serving two completely unlabelled rounds if we don't set the min number of labelled images to 1 per captcha round)
-    // load the map to get the labelled and unlabelled data
-    const labelled: LabelledItem[] = labelledMapFile
-        ? LabelledDataSchema.parse(JSON.parse(fs.readFileSync(labelledMapFile, 'utf8'))).items
-        : []
-    const unlabelled: Item[] = unlabelledMapFile
-        ? DataSchema.parse(JSON.parse(fs.readFileSync(unlabelledMapFile, 'utf8'))).items
-        : []
-    // check for duplicates
-    checkDuplicates(labelled, unlabelled, {
-        allowDuplicatesLabelled,
-        allowDuplicatesUnlabelled,
-    })
-    // split the labelled data by label
-    const labelToImages: { [label: string]: Item[] } = {}
-    for (const entry of labelled) {
-        labelToImages[entry.label] = labelToImages[entry.label] || []
-        labelToImages[entry.label].push(entry)
-    }
-    const targets = Object.keys(labelToImages)
-    // load the labels from file
-    // these are the labels that unlabelled data will be assigned to
-    // note that these can be differen to the labels in the map file as the labelled data is independent of the unlabelled data in terms of labels
-    const labels: string[] = []
-    if (labelsFile && fs.existsSync(labelsFile)) {
-        labels.push(...[...LabelsContainerSchema.parse(JSON.parse(fs.readFileSync(labelsFile, 'utf8'))).labels])
-    } else {
-        // else use the labels from the labelled data
-        labels.push(...[...targets])
-    }
-    // generate n captchas
-    const captchas: CaptchaWithoutId[] = []
-    for (let i = 0; i < count; i++) {
-        logger.info(`generating captcha ${i + 1} of ${count}`)
-
-        if (targets.length <= 1) {
-            throw new ProsopoEnvError(
-                new Error(`not enough different labels in labelled data: ${labelledMapFile}`),
-                'DATASET.NOT_ENOUGH_LABELS'
-            )
-        }
-
-        // uniformly sample targets
-        const target = targets[i % targets.length]
-        const notTargets = targets.filter((t) => t !== target)
-        // how many labelled images should be in the captcha?
-        const nLabelled = _.random(minLabelled, maxLabelled)
-        // how many correct labelled images should be in the captcha?
-        const maxCorrect = nLabelled - minCorrect
-        const nCorrect = _.random(minCorrect, maxCorrect)
-        const nIncorrect = nLabelled - nCorrect
-        const nUnlabelled = size - nLabelled
-
-        const targetItems = labelToImages[target]
-        const notTargetItems: Item[] = notTargets.map((notTarget) => labelToImages[notTarget]).flat()
-
-        if (nUnlabelled > unlabelled.length) {
-            throw new ProsopoEnvError(new Error(`not enough unlabelled data`), 'DATASET.NOT_ENOUGH_IMAGES')
-        }
-        if (nCorrect > targetItems.length) {
-            throw new ProsopoEnvError(
-                new Error(`not enough images for target (${target})`),
-                'DATASET.NOT_ENOUGH_IMAGES'
-            )
-        }
-        if (nIncorrect > notTargetItems.length) {
-            throw new ProsopoEnvError(
-                new Error(`not enough non-matching images for target (${target})`),
-                'DATASET.NOT_ENOUGH_IMAGES'
-            )
-        }
-
-        // get the correct items
-        const correctItems: Item[] = _.sampleSize(targetItems, nCorrect)
-
-        // get the incorrect items
-        const incorrectItems: Item[] = _.sampleSize(notTargetItems, nIncorrect)
-
-        // get the unlabelled items
-        const unlabelledItems = new Set<Item>()
-        while (unlabelledItems.size < size - nLabelled) {
-            // get a random image from the unlabelled data
-            const image = unlabelled[_.random(0, unlabelled.length - 1)]
-            unlabelledItems.add(image)
-        }
-
-        let items: Item[] = [...correctItems, ...incorrectItems, ...unlabelledItems]
-        let indices: number[] = [...Array(items.length).keys()]
-        indices = _.shuffle(indices)
-        items = indices.map((i) => items[i])
-        items = items.map((item) => {
-            return {
-                data: item.data,
-                hash: item.hash,
-                type: item.type,
-            }
-        })
-
-        // the first n indices are the correct items
-        const solution: RawSolution[] = indices
-            .map((index, i) => {
-                return {
-                    pre: index, // the index of the item in the items array before shuffle
-                    post: i, // the index of the item in the shuffled array
-                }
-            })
-            .filter((item) => item.pre < correctItems.length) // keep all items that were in the first n slots of the original item array - these were the correct items
-            .map((item) => {
-                return item.post // return the index in the shuffled array
-            })
-
-        // the unlabelled indices were after the correct and incorrect
-        const unlabelledIndices: RawSolution[] = indices
-            .map((index, i) => {
-                return {
-                    pre: index, // the index of the item in the items array before shuffle
-                    post: i, // the index of the item in the shuffled array
-                }
-            })
-            .filter((item) => item.pre >= correctItems.length + incorrectItems.length) // keep all items that were in the first n slots of the original item array - these were the correct items
-            .map((item) => {
-                return item.post // return the index in the shuffled array
-            })
-
-        const salt = blake2AsHex(bcrypt.genSaltSync(saltRounds))
-        // create the captcha
-        const captcha: CaptchaWithoutId = {
-            salt,
-            target,
-            items,
-            solution,
-            unlabelled: unlabelledIndices,
-        }
-        captchas.push(captcha)
-    }
-    // write to file
-    const output: Captchas = {
-        captchas,
-        format: CaptchaTypes.SelectAll,
-    }
-
-    // verify the output
-    CaptchasContainerSchema.parse(output)
-
-    fs.writeFileSync(outFile, JSON.stringify(output, null, 4))
-}

package/src/generate/union/index.ts

@@ -1,3 +0,0 @@
-export * from './generate.js'
-export * from './cli.js'
-export * from './args.js'

package/src/generate/util.ts

@@ -1,61 +0,0 @@
-import { Item, LabelledItem } from '@prosopo/types'
-
-export const checkDuplicates = (
-    labelled: LabelledItem[],
-    unlabelled: Item[],
-    options: {
-        allowDuplicatesLabelled?: boolean
-        allowDuplicatesUnlabelled?: boolean
-    }
-) => {
-    // check for duplicates
-    const all = new Set<string>()
-    if (!options.allowDuplicatesLabelled) {
-        for (const entry of labelled) {
-            if (all.has(entry.data)) {
-                throw new Error(`Duplicate data entry in labelled data: ${JSON.stringify(entry)}`)
-            }
-            all.add(entry.data)
-        }
-    }
-    if (!options.allowDuplicatesUnlabelled) {
-        for (const entry of unlabelled) {
-            if (all.has(entry.data)) {
-                throw new Error(`Duplicate data entry in unlabelled data: ${JSON.stringify(entry)}`)
-            }
-        }
-    }
-}
-
-export const choice = <T>(
-    items: T[],
-    n: number,
-    random: () => number,
-    options?: {
-        withReplacement?: boolean
-    }
-): {
-    choices: T[]
-    indices: number[]
-} => {
-    if (n > items.length) {
-        throw new Error(`n (${n}) cannot be greater than items.length (${items.length})`)
-    }
-    options = options || {}
-
-    const indicesSet = new Set<number>()
-    const indices: number[] = []
-    while (indices.length < n) {
-        const index = Math.abs(Math.round(random())) % items.length
-        // with replacement == allow duplicates
-        // without replacement == don't allow duplicates
-        if (options.withReplacement || indicesSet.add(index)) {
-            indices.push(index)
-        }
-    }
-
-    return {
-        choices: indices.map((index) => items[index]),
-        indices,
-    }
-}

package/src/get/args.ts

@@ -1,9 +0,0 @@
-// Args for generating a dataset
-
-import { z } from 'zod'
-
-export const argsSchema = z.object({
-    data: z.string(),
-})
-
-export type Args = z.infer<typeof argsSchema>

package/src/get/cli.ts

@@ -1,21 +0,0 @@
-import { ArgumentsCamelCase, Argv } from 'yargs'
-import { Logger } from '@prosopo/common'
-import { argsSchema } from './args.js'
-import get from './get.js'
-
-export default (cmdArgs?: { logger?: Logger }) => {
-    return {
-        command: 'get',
-        describe: 'Test a GET request at image URLs',
-        builder: (yargs: Argv) => {
-            return yargs.option('data', {
-                type: 'string',
-                demand: true,
-                description: 'JSON file containing urls under a "data" key',
-            })
-        },
-        handler: async (argv: ArgumentsCamelCase) => {
-            await get(argsSchema.parse(argv), cmdArgs?.logger)
-        },
-    }
-}

package/src/get/get.ts

@@ -1,56 +0,0 @@
-import { Args } from './args.js'
-import { Logger, ProsopoEnvError, getLoggerDefault } from '@prosopo/common'
-import fetch from 'node-fetch'
-import fs from 'fs'
-
-export default async (args: Args, loggerOpt?: Logger) => {
-    const logger = loggerOpt || getLoggerDefault()
-
-    logger.debug(args, 'getting...')
-
-    const traverse = async (data: JSON) => {
-        if (data instanceof Array) {
-            for (let i = 0; i < data.length; i++) {
-                data[i] = await traverse(data[i])
-            }
-        } else if (data instanceof Object) {
-            for (const key of Object.keys(data)) {
-                if (key == 'data') {
-                    const url = data[key]
-                    if (url.startsWith('http')) {
-                        try {
-                            const response = await fetch(url)
-                            if (!response.ok) {
-                                logger.error(`GET ${url} ${response.status} ${response.statusText}`)
-                            } else {
-                                logger.log(`GET ${url} OK`)
-                            }
-                        } catch (err) {
-                            logger.error(err)
-                        }
-                    } else {
-                        // resolve locally
-                        try {
-                            fs.readFileSync(url)
-                            logger.log(`GET ${url} OK`)
-                        } catch (err) {
-                            logger.error(`GET ${url} ${err}`)
-                        }
-                    }
-                } else {
-                    await traverse(data[key])
-                }
-            }
-        }
-        return data
-    }
-
-    const file = args.data
-    if (!fs.existsSync(file)) {
-        throw new ProsopoEnvError(new Error(`file does not exist: ${file}`), 'FS.FILE_NOT_FOUND')
-    }
-
-    // read the map file
-    const data: JSON = JSON.parse(fs.readFileSync(file, 'utf8'))
-    await traverse(data)
-}

package/src/get/index.ts

@@ -1,3 +0,0 @@
-export * from './get.js'
-export * from './cli.js'
-export * from './args.js'