Function generateCli

scripts/generate-cli.ts:108–222

()

}

async function generateCli() {
  const tools = await fetchTools();

  const staticTools = createTools(parseArguments());
  const toolNameToCategoryEnum = new Map<string, string>();
  const toolNameToConditions = new Map<string, string[]>();

  for (const tool of staticTools) {
    toolNameToCategoryEnum.set(tool.name, tool.annotations.category);
    toolNameToConditions.set(tool.name, tool.annotations.conditions || []);
  }

  // Sort tools by name
  const sortedTools = tools
    .sort((a, b) => a.name.localeCompare(b.name))
    .filter(tool => {
      // Skipping fill_form because it is not relevant in shell scripts
      // and CLI does not handle array/JSON args well.
      if (tool.name === 'fill_form') {
        return false;
      }
      // Skipping wait_for because CLI does not handle array/JSON args well
      // and shell scripts have many mechanisms for waiting.
      if (tool.name === 'wait_for') {
        return false;
      }
      // Skipping get_tab_id as it is for internal integrations
      if (tool.name === 'get_tab_id') {
        return false;
      }
      // Skipping in_page tools as they are not launched yet
      if (toolNameToCategoryEnum.get(tool.name) === ToolCategory.IN_PAGE) {
        return false;
      }
      return true;
    });

  const commands: Record<
    string,
    {description: string; category: string; args: Record<string, CliOption>}
  > = {};

  for (const tool of sortedTools) {
    const options = schemaToCLIOptions(tool.inputSchema);
    const args: Record<string, CliOption> = {};
    for (const opt of options) {
      args[opt.name] = opt;
    }

    const categoryEnum = toolNameToCategoryEnum.get(tool.name);
    if (!categoryEnum) {
      throw new Error(`Tool ${tool.name} has no category.`);
    }
    const category = labels[categoryEnum as unknown as keyof typeof labels];
    if (!tool.description) {
      throw new Error(`Tool ${tool.name} is missing description`);
    }