Command Definition

@CommandDefinition(
    name = "copy",
    aliases = {"cp"},
    description = "Copy files",
    generateHelp = true
)
public class CopyCommand implements Command<CommandInvocation> {
    
    @Option(shortName = 'r', description = "Recursive copy")
    private boolean recursive;

    @Override
    public CommandResult execute(CommandInvocation invocation) {
        // implementation
        return CommandResult.SUCCESS;
    }
}

public interface Command<T extends CommandInvocation> {
    CommandResult execute(T commandInvocation) 
        throws CommandException, InterruptedException;
}

public class ConfigDefaultProvider implements DefaultValueProvider {

    @Override
    public String defaultValue(ProcessedOption option) {
        // Use option.name() and option.parent().name() to build a config key
        String key = option.parent().name() + "." + option.name();
        return Configuration.get(key);  // returns null if not configured
    }
}

@CommandDefinition(
    name = "init",
    description = "Initialize a project",
    defaultValueProvider = ConfigDefaultProvider.class
)
public class InitCommand implements Command<CommandInvocation> {

    @Option(defaultValue = "hello")
    private String template;

    @Option
    private String editor;

    @Override
    public CommandResult execute(CommandInvocation invocation) {
        invocation.println("Template: " + template);
        invocation.println("Editor: " + editor);
        return CommandResult.SUCCESS;
    }
}

// Provider returns "from-config" for template -> uses "from-config"
// Provider returns null for editor -> falls back to static default "vi"
@Option(defaultValue = "vi")
private String editor;

// Via AeshRuntimeRunner
AeshRuntimeRunner.builder()
    .command(MyApp.class)
    .defaultValueProvider(new ConfigDefaultProvider())
    .execute();

// Via AeshCommandRegistryBuilder
CommandRegistry registry = AeshCommandRegistryBuilder.builder()
    .defaultValueProvider(new ConfigDefaultProvider())
    .command(RunCommand.class)
    .command(BuildCommand.class)
    .create();

// Via AeshCommandRuntimeBuilder
CommandRuntime runtime = AeshCommandRuntimeBuilder.builder()
    .commandRegistry(registry)
    .defaultValueProvider(new ConfigDefaultProvider())
    .build();

@CommandDefinition(
    name = "run",
    description = "Run a script",
    stopAtFirstPositional = true,
    generateHelp = true
)
public class RunCommand implements Command<CommandInvocation> {

    @Option(hasValue = false, description = "Enable verbose output")
    private boolean verbose;

    @Arguments
    private List<String> args;

    @Override
    public CommandResult execute(CommandInvocation invocation) {
        // args contains the script name and all arguments after it
        return CommandResult.SUCCESS;
    }
}

@CommandDefinition(
    name = "build",
    description = "Build project",
    sortOptions = true,
    generateHelp = true
)
public class BuildCommand implements Command<CommandInvocation> {

    @Option(description = "Always first", order = 10)
    private boolean ci;

    @Option(description = "Build profile", order = 20)
    private String profile;

    @Option(description = "Clean output")
    private boolean clean;

    @Option(description = "Verbose output")
    private boolean verbose;

    @Override
    public CommandResult execute(CommandInvocation invocation) {
        return CommandResult.SUCCESS;
    }
}

@GroupCommandDefinition(
    name = "cli",
    description = "My CLI tool",
    generateHelp = true,
    groupCommands = {
        BuildCommand.class, TestCommand.class,
        InstallCommand.class, PublishCommand.class,
        InfoCommand.class, VersionCommand.class
    }
)
public class CliCommand implements GroupCommand<CommandInvocation> {
    @Override
    public CommandResult execute(CommandInvocation invocation) {
        return CommandResult.SUCCESS;
    }
}

@CommandDefinition(name = "build", description = "Build the project", helpGroup = "Build")
public class BuildCommand implements Command<CommandInvocation> { /* ... */ }

@CommandDefinition(name = "test", description = "Run tests", helpGroup = "Build")
public class TestCommand implements Command<CommandInvocation> { /* ... */ }

@CommandDefinition(name = "install", description = "Install dependencies", helpGroup = "Publish")
public class InstallCommand implements Command<CommandInvocation> { /* ... */ }

@CommandDefinition(name = "publish", description = "Publish package", helpGroup = "Publish")
public class PublishCommand implements Command<CommandInvocation> { /* ... */ }

@CommandDefinition(name = "info", description = "Show project info")
public class InfoCommand implements Command<CommandInvocation> { /* ... */ }

@CommandDefinition(name = "version", description = "Show version")
public class VersionCommand implements Command<CommandInvocation> { /* ... */ }

public class PluginHelpProvider implements HelpSectionProvider {

    @Override
    public Map<String, List<HelpEntry>> getAdditionalSections() {
        Map<String, List<HelpEntry>> sections = new LinkedHashMap<>();

        // Discover plugins at runtime
        List<HelpEntry> plugins = new ArrayList<>();
        plugins.add(new HelpEntry("docker", "Docker integration plugin"));
        plugins.add(new HelpEntry("k8s", "Kubernetes deployment plugin"));
        sections.put("Plugins", plugins);

        return sections;
    }
}

@GroupCommandDefinition(
    name = "app",
    description = "My application",
    generateHelp = true,
    groupCommands = {RunCommand.class, BuildCommand.class},
    helpSectionProvider = PluginHelpProvider.class
)
public class AppCommand implements GroupCommand<CommandInvocation> {
    @Override
    public CommandResult execute(CommandInvocation invocation) {
        return CommandResult.SUCCESS;
    }
}

public class JBangHelpProvider implements HelpSectionProvider {

    @Override
    public String getHeader() {
        return "jbang - Unleash the power of Java\n"
             + "  jbang init hello.java        (initialize a script)\n"
             + "  jbang hello.java [args...]    (run a .java file)";
    }

    @Override
    public String getFooter() {
        return "See https://jbang.dev for more info";
    }

    @Override
    public Map<String, List<HelpEntry>> getAdditionalSections() {
        return Collections.emptyMap();
    }
}