Tiny CLI

The tiny CLI provides three categories of commands:

1. Base commands: Core functionality for initialization, installation, and management.
2. Toolkit-specific commands: Commands fixed to a specific toolkit.
3. Plugin extension commands: Commands provided by installed plugins.

You can view the help information by running tiny -h.

$ tiny -h

tiny-cli provides several advanced capabilities for frontend workflows:

• Cross-platform compatibility: Works on Windows, macOS, and Linux.
• Advanced Task Execution: Offers a more powerful task flow execution mechanism than standard npm scripts, providing better control over synchronous and asynchronous task execution.
• Automated Module Installation: Supports automatic installation of modules. If you run a module command that is not currently installed locally, tiny-cli will automatically install it before executing the command.
• Flexible Upgrade Strategies: Modules can be configured for automatic upgrades, manual upgrades, or 'last-digit automatic upgrades' (where the user is automatically upgraded when the module's version number changes in the last digit/z-position).
• Improved Error Handling: Provides human-readable error messages to make debugging easier.

tiny-cli is a core frontend engineering tool designed to provide a robust set of tools, suites, plugins, and workflows. It operates on a unified development environment to ensure consistency and reproducibility across teams.

Core Mental Model: Tiny follows a design philosophy similar to npm. Just as npm is primarily a package manager rather than a build tool, tiny itself does not possess inherent engineering capabilities. Instead, it serves as a platform for installing, managing, and running specialized suites (scaffolding tools) and plugins (task runners).

It provides:

• Scaffolding functionality (similar to Yeoman) to quickly set up local development environments.
• A plugin mechanism (similar to Gulp) to solve various frontend development challenges.

A tiny plugin is a standard npm package that exports a single object. The keys of this exported object map directly to commands used in the CLI.

Command Syntax: tiny <plugin-name> <command>

If your plugin is named tiny-plugin-abc, the exported object keys become the subcommands. For example, an object with a go key allows the user to run tiny abc go.

// Example implementation for tiny-plugin-abc
module.exports = {
  go: function() { console.log('go') },
  help: function() { /* help logic */ }
};

// CLI Usage:
// $ tiny abc go

The devkit is an object collection that integrates all Tiny dependencies. It exposes several sub-objects, each providing a specific category of operations (e.g., cache for data storage, logs for console output, config for file manipulation). You can destructure the specific utilities you need directly from the package.

import { cache, logs } from '@opentiny/cli-devkit';

const log = logs('my-logger');
log.info('message');
cache.set('key', 'value');

When developing a toolkit, you must adhere to these naming and versioning rules:

• Naming: The name field in your package.json must follow the format @opentiny/tiny-toolkit-xxx.
• Versioning: You must follow the semver specification.

You can define custom tasks in the tasks object. If a task name matches an existing toolkit command, the user-defined tasks will execute before the toolkit's native command.

Tasks can be defined as an array of command objects. Each object can include an async boolean: if set to true, the CLI will not wait for that specific command to complete before proceeding to the next one in the sequence.

{
   tasks: {
        // Commands executed before 'start'
        start: [{
            command: 'echo test1'
        },{            
            command: 'tiny server',
            // Set async to true to not wait for this command to finish before the next one
            async: true
        }],
        // Commands executed before 'build'
        build: [{
            command: 'gulp clean'
        }]
   }
}

Tiny toolkits are standard npm packages that can run independently. The connection between the tiny CLI and your toolkit is established via the toolkit field in the project's tiny.config.js file.

When a user runs a command like tiny <command>, the tiny CLI looks up the toolkit specified in tiny.config.js and executes the function corresponding to <command> within that toolkit's exported object.

// In tiny.config.js
module.exports = {
  toolkit : "@opentiny/tiny-toolkit-abc"
}