commander#program TypeScript Examples

export function run(argv: string[]): void {
  try {
    program
      .name('anchorcli')
      .version('0.0.1')
      .option('-v,--verbose', 'Show verbose error logs')
      .description(
        'Command-line interface for interacting with Anchor Protocol on Terra',
      );
    _.each(commands, (command: Command) => {
      program.addCommand(command);
    });
    program.parse(argv);
  } catch (e) {
    logger.error(e.message);
  }
}

async function main() {
  await program
    .version(VERSION)
    .option(
      "-c, --config <path>",
      "path to tailwind.config.js",
      "./tailwind.config.js"
    )
    .option("-w, --watch", "watch files", false)
    .parseAsync(process.argv);

  await run(program);
}

program
    .command('generate')
    .alias('g')
    .option('--aliasName <string>')
    .option('--file <string>')
    .option('--url <string>')
    .option('--output <string>')
    .option('--configOutput <string>')
    .option('--all')
    .option('--withRequestOptions')
    .description('Generates models and services')
    .action(async (params) => {
        const options = getOptions(params);
        const spec = await getOpenAPISpec(options);
        const codeGen = new GenGenCodeGen(options, spec);
        await codeGen.run();
    });

private preAction = async () => {
        this.profile = program.profile || "default";
        this.adapter = program.adapter || "hci0";

        if (program.debug) logger.setLevel(logger.LEVEL.DEBUG);

        this.config = new ConfigManager(this.profile);

        await this.bluetooth.init(this.adapter);
    }

/**
	 * @param {CommandDescriptor} commandDescription an immutable representation of a command
	 * @param {string[]} argv a custom argv for testing purposes
	 */
	constructor(readonly commandDescription: CommandDescriptor, program: CliApiObject = programApi) {
		program.name('ardrive');
		program.addHelpCommand(true);
		program.usage('[command] [command-specific options]');
		// Override the commander's default exit (process.exit()) to avoid abruptly interrupting the script execution
		program.exitOverride();
		setCommanderCommand(this.commandDescription, program);
		CLICommand.allCommandInstances.push(this);
	}

main = (argv: string[]) => {
  program.name('backstage-cli').version(version);

  registerCommands(program);

  program.on('command:*', () => {
    console.log();
    console.log(chalk.red(`Invalid command: ${program.args.join(' ')}`));
    console.log();
    program.outputHelp();
    process.exit(1);
  });

  program.parse(argv);
}

program.parseAsync().catch((error) => {
  if (typeof error === "string") console.log(kleur.red(error));
  else if (error instanceof TezosOperationError) {
    console.log(kleur.red(`Tezos operation error: ${kleur.bold(error.message)}`));
  } else {
    console.log(kleur.red("unknown error:"));
    console.log(error);
  }
});

function programCommand(name: string) {
  return program
    .command(name)
    .option(
      '-e, --env <string>',
      'Solana cluster env name, i.e. mainnet-beta, testnet, devnet',
      'devnet', //mainnet-beta, testnet, devnet
    )
    .option(
      '-k, --keypair <path>',
      `Solana wallet location`,
      '--keypair not provided',
    )
    .option('-l, --log-level <string>', 'log level', setLogLevel);
}

program
	.command("gen-config")
	.description("Generate a config file")
	.option(
		"-d, --docker",
		"Generate the docker config instead of the normal one"
	)
	.action((options) => {
		generateConfig(options);
	});

commonOpts(program.command("edit"))
  .option("-p, --port <port>", "Port to run local server", parseInt)
  .option("-s, --static <dir>", "Directory to serve static files")
  .action(
    async (file, { config, ...opts }) =>
      await server.main({
        file,
        config: await loadConfig(config),
        ...opts,
      })
  );

//prettier-ignore
program
  .command('init')
  .alias('i')
  .description('create tzgen.json file with the generator environment settings')
  .option('-l --ligo <ligo_dir>', 'ligo code directory. The default is ./ligo')
  .option('-o --compile-out <out_dir>', 'contract compilation output directory. The default is ./ligo/out')
  .option('-t --ts <ts_dir>', 'TypeScript source directory. The default is ./src')
  .action(async options => initConfig(options.ligo, options.compileOut, options.ts));

async function main(): Promise<void> {
  program.requiredOption("--start <yyyy/MM>").requiredOption("--end <yyyy/MM>").requiredOption("--query <query>");

  program.parse(process.argv);

  const startDate = parse(program.start, "yyyy/MM", new Date());
  const endDate = parse(program.end, "yyyy/MM", new Date());
  const query = program.query as string;

  const allStats = [];
  for (let start = startDate; start <= endDate; start = addMonths(start, 1)) {
    const end = add(start, { months: 1, seconds: -1 });
    console.error(format(start, "yyyy-MM-dd HH:mm:ss"));
    console.error(format(end, "yyyy-MM-dd HH:mm:ss"));

    const stdout = execFileSync(
      "merged-pr-stat",
      ["--start", start.toISOString(), "--end", end.toISOString(), "--query", query],
      { encoding: "utf8" }
    );
    const result = {
      startDate: format(start, "yyyy-MM-dd HH:mm:ss"),
      endDate: format(end, "yyyy-MM-dd HH:mm:ss"),
      ...JSON.parse(stdout),
    };
    allStats.push(result);
  }
  process.stdout.write(csvStringify(allStats, { header: true }));
}

export function run(): void {
    program.description(`
Generates TypeScript definitions for evm log events
for use within substrate-processor mapping handlers.
    `.trim())
        .requiredOption('--abi <path>', 'path to a JSON abi file')
        .requiredOption('--output <path>', 'path for output typescript file');

    program.parse();

    const options = program.opts();
    const inputPath = options.abi;
    const outputPath = options.output;

    try {
        generateTsFromAbi(inputPath, outputPath);
    } catch(err: any) {
        console.error(`evm-typegen error: ${err.toString()}`);
        process.exit(1);
    }
}

// 创建项目
program
  .command('create')
  .description('create mf-lite project template for base-app or micro-app')
  .action(
    async () => {
      await launchPlopByConfig('micro-fe-generator');
    }
  );

process.on('unhandledRejection', (error) => {
  if (program.verbose) {
    console.error(error);
    logger.error(error.toString());
  } else {
    logger.error(error.toString() + '; use --verbose for more details');
  }
});

program
    .command('init')
    .option('--configOutput <string>')
    .description('Creates file to select endpoints for generation')
    .action(() => gengen.init());

parse(argv: string[]) {
        program.parse(argv);
    }

public static parse(program: CliApiObject = programApi, argv: string[] = process.argv): void {
		program.parse(argv);
		this.rejectNonTriggeredAwaiters();
	}

async function main(argv: string[], env: NodeJS.ProcessEnv) {
  program
    .option('-d, --debug', 'enable debug output')
    .option('-v, --verbose', 'enable verbose output')
    .option(
      '--network <network>',
      `specify NEAR network ID (default: "${env.NEAR_ENV || 'local'}")`
    )
    .option(
      '--engine <account>',
      `specify Aurora Engine account ID (default: "${
        env.AURORA_ENGINE || 'aurora.test.near'
      }")`
    )
    .option(
      '-B, --block <block>',
      `specify block height to begin indexing from (default: 0)`
    )
    .option(
      '--batch-size <batchSize>',
      `specify batch size for fetching block metadata (default: 1000)`
    )
    .parse(argv);

  const opts = program.opts() as Config;
  const [network, config] = parseConfig(
    opts,
    (externalConfig as unknown) as Config,
    env
  );
  const blockID = opts.block !== undefined ? parseInt(opts.block as string) : 0;

  if (config.debug) {
    for (const source of externalConfig.util.getConfigSources()) {
      console.error(`Loaded configuration file ${source.name}.`);
    }
    console.error('Configuration:', config);
  }

  logger.info('starting reindexing of events');
  const engine = await Engine.connect(
    {
      network: network.id,
      endpoint: config.endpoint,
      contract: config.engine,
    },
    env
  );
  const indexer = new ReindexWorker(config, network, logger, engine);
  await indexer.run(blockID, 'follow');
}

main = (argv: string[]) => {
  program.name('techdocs-cli').version(version);

  registerCommands(program);

  program.parse(argv);
}

options = program.opts()

json = JSON.parse(fs.readFileSync(program.input, { encoding: 'utf8' }))

function commandWithDefaultOption(commandName: string): Command {
	return program
		.command(commandName)
		.option('-e, --env <env>', 'environment e.g devnet, mainnet-beta')
		.option('-k, --keypair <path>', 'Solana wallet')
		.option('-u, --url <url>', 'rpc url e.g. https://api.devnet.solana.com');
}

options = program.opts()

// configuration

program.version(packageJson.version);