#!/usr/bin/env -S node --experimental-import-meta-resolve --no-warnings
import { cli, run, flag, command } from '@ivyrun/input';

async function input(parsedARGV) {
    await command('init', {
        description: 'init a new project',
        usage: 'hello-world init',
        has_flag: true,
        cb: () => {
            console.log('init');
        }
    });
    await flag('--bare', {
        description: 'init a new project without any dependencies',
        usage: 'hello-world init --bare',
        is_flag_of: 'init',
        cb: () => {
            console.log('init --bare');
        }
    });
    await cli(parsedARGV);
}
await run(process.argv, input, 'hello-world');

#!/usr/bin/env node --experimental-meta-resolve --no-warnings

import { readFile } from 'node:fs/promises'
import { command, run } from '@ivyrun/input'
import { extname } from 'node:path'

// The very entry point of the cli application
const app = async (parsed) => {

  // The read command callback function
  const read_cb = async (data) => {

    let exitCode = 0

    // Get the filename
    const filename = `${process.cwd()}/${data.flag['--filename'] || data.flag['-f']}`

    // only json files are allowed
    if(extname(filename) !== '.json'){
      console.error('only json file')
      process.exit(1)
    }

    // It reads the file, and if the readFile fails, it returns a json string with the error message given.
    const content = await readFile(filename, { encoding: 'utf-8' }).catch(error => {
      exitCode = 1

      return `{"error":"${ error.message }"}`
    })

    // It converts to object the give json data.
    let json_data
    try{
      json_data = JSON.parse(content)
    }catch ( error ) {
      json_data = `{"error":"${error.message}"}`
      exitCode = 1
    }

    console.log(json_data)
    process.exit(exitCode)
  };

  // Instantiate a new Command and pass to the constructor the parsed argument
  const read = new Command(parsed)

  /**
   *  Define your first command
   *
   *  1. name your command
   *  2. pass the read callback function
   *  3. give it a description & usage to populate the help system
   *
   *  READ COMMAND
   */
  await read.define('read', read_cb, {
    description: 'read a file and print the content',
    usage: './index.js read --filename=test.json'
  })

  /**
   * Define the flag --filename[-f]
   *
   * 1. define the names with a string[] one for short and one for long:
   *    '--filename', '-f'
   * 2. populate descriptor argument
   * 3. give it a description & usage to the descriptor to populate the help system
   *
   * READ --FILENAME FLAG
   */
  await read.flag(['--filename', '-f'], {
    short: '-f',
    long: '--filename',
    type: 'string',
    void: false,
    check: true,
    description: 'ONLY relative path to the current working dir of the app, ⚠️ no slash or dot needed!',
    usage: './index.js read --filename=test.json'
  })

  // This will intercept the given data and execute the routines
  await read.intercept()
};

// - entry_point will process the process.argv data and gives back the object version to app function
await entry_point(process.argv, app).catch(error => console.error(error))