`typescript
import { loadCommandPackage } from '@skill-kit/cli';

const result = await loadCommandPackage('analytics');
if (result.success) {
// Use loaded package
const analytics = result.module;
} else {
// Handle package not installed
console.error(result.error.message);
}
`

$3

The CLI maintains a command-to-package mapping:

`typescript
const PACKAGE_MAP = {
lint: '@skill-kit/lint',
init: '@skill-kit/init',
install: '@skill-kit/registry',
list: '@skill-kit/registry',
update: '@skill-kit/registry',
outdated: '@skill-kit/registry',
remove: '@skill-kit/registry',
distill: '@skill-kit/distill',
convert: '@skill-kit/convert',
test: '@skill-kit/test',
sync: '@skill-kit/sync',
analytics: '@skill-kit/analytics',
compose: '@skill-kit/compose',
doc: '@skill-kit/doc',
};
`

Command Suggestions

When users enter unknown commands, the CLI provides smart suggestions:

`bash
$ skill anlytics

Error: Unknown command "anlytics"

Did you mean "analytics"?

Available commands:
- init
- lint
- install
- list
...
`

The suggestion feature is based on string similarity algorithms (Levenshtein distance) and shows up to 3 suggestions.

Error Handling

When a required package is not installed, the CLI provides clear installation guidance:

`bash
$ skill analytics
Error: Command "analytics" requires @skill-kit/analytics

Install it with:
npm install @skill-kit/analytics
or
pnpm add @skill-kit/analytics
`

Exit Codes

The CLI uses standard exit codes:

| Exit Code | Meaning |
| --------- | ----------------- |
| 0 | Success |
| 1 | General error |
| 2 | Invalid argument |
| 127 | Command not found |

API Reference

$3

`typescript
interface PackageLoadResult {
success: boolean;
module?: T;
error?: Error;
}

interface GlobalOptions {
verbose?: boolean;
quiet?: boolean;
config?: string;
color?: boolean;
}

const ExitCode = {
SUCCESS: 0,
ERROR: 1,
INVALID_ARGUMENT: 2,
COMMAND_NOT_FOUND: 127,
} as const;
`

$3

`typescript
// Get package name for command
getPackageName(command: string): string | undefined;

// Get all command list
getAllCommands(): string[];

// Get all unique package names
getUniquePackages(): string[];

// Dynamically load package
loadPackage(packageName: string): Promise>;

// Load command package
loadCommandPackage(command: string): Promise>;

// Check if package is installed
isPackageInstalled(packageName: string): boolean;

// Print missing package error
printMissingPackageError(command: string, packageName: string): void;

// Suggest command
suggestCommand(input: string, maxSuggestions?: number): string[];

// Format suggestions
formatSuggestions(suggestions: string[]): string;
`

$3

`typescript
// Register various commands
registerLintCommand(program: Command): void;
registerInitCommand(program: Command): void;
registerInstallCommand(program: Command): void;
registerListCommand(program: Command): void;
registerUpdateCommand(program: Command): void;
registerOutdatedCommand(program: Command): void;
registerRemoveCommand(program: Command): void;
registerDistillCommand(program: Command): void;
registerConvertCommand(program: Command): void;
registerTestCommand(program: Command): void;
registerSyncCommand(program: Command): void;
registerAnalyticsCommand(program: Command): void;
registerComposeCommand(program: Command): void;
registerDocCommand(program: Command): void;
`

$3

`typescript
// Handle unknown command
handleUnknownCommand(): void;

// Handle missing package
handleMissingPackage(command: string): void;

// Handle error
handleError(error: unknown): void;

// Handle invalid argument
handleInvalidArgument(message: string): void;
`

Usage Examples

$3

`bash


Show help

`bash


Initialize new skill and lint immediately

`bash


CLI will automatically provide suggestions

Available commands:
- init
- lint
- install
...
`

Troubleshooting

$3

If you receive an "Unknown command" error, check:

1. Is the command spelled correctly
2. Is the corresponding package installed
3. Is the package in the correct location

The CLI will automatically provide suggestions for similar commands.

$3

If you receive a package loading error:

1. Run npm list @skill-kit/ to check if package is installed
2. Reinstall the package: npm install @skill-kit/
3. Clear npm cache: npm cache clean --force

$3

Some commands support subcommands. If a subcommand is not recognized:

1. Check if parent command is correct
2. Use --help to see supported subcommands
3. Ensure you're using the correct subcommand name

For example, skill distill requires specifying a subcommand (run, list, show).

Development

$3

`
packages/cli/
├── src/
│ ├── cli.ts # Main CLI entry
│ ├── index.ts # API exports
│ ├── types.ts # Type definitions
│ ├── commands/ # Command implementations
│ │ ├── index.ts
│ │ ├── init.ts
│ │ ├── lint.ts
│ │ ├── registry.ts
│ │ ├── distill.ts
│ │ ├── convert.ts
│ │ ├── test.ts
│ │ ├── sync.ts
│ │ ├── analytics.ts
│ │ ├── compose.ts
│ │ └── doc.ts
│ └── utils/ # Utility functions
│ ├── index.ts
│ ├── loader.ts # Package loader
│ ├── suggest.ts # Command suggestions
│ └── error.ts # Error handling
├── tests/ # Test files
├── package.json
├── tsconfig.json
└── README.md
`

$3

To add a new CLI command:

1. Create new command file in src/commands/
2. Implement command registration function
3. Register command in src/cli.ts
4. Export in src/commands/index.ts
5. Update package mapping in src/utils/loader.ts (if needed)

`typescript
// src/commands/mycommand.ts
import type { Command } from 'commander';
import { loadCommandPackage, handleMissingPackage, handleError } from '../utils/index.js';

interface MyCommandModule {
run: (options: unknown) => Promise;
}

export function registerMyCommand(program: Command): void {
program
.command('mycommand')
.description('My custom command')
.option('--option ', 'An option')
.action(async (options: { option?: string }) => {
const result = await loadCommandPackage('mycommand');
if (!result.success || !result.module) {
handleMissingPackage('mycommand');
return;
}

try {
await result.module.run(options);
} catch (error) {
handleError(error);
}
});
}
`

Then in src/cli.ts:

`typescript
import { registerMyCommand } from './commands/mycommand.js';

// ... other commands
registerMyCommand(program);
`

$3

`bash


Run tests

`bash


Build project

- commander: Command-line framework
- chalk: Terminal colored output
- cli-table3: Table output
- @skill-kit/core: Core library

$3

CLI optional dependencies include all feature packages:

- @skill-kit/lint
- @skill-kit/init
- @skill-kit/registry
- @skill-kit/distill
- @skill-kit/convert
- @skill-kit/test
- @skill-kit/sync
- @skill-kit/analytics
- @skill-kit/compose
- @skill-kit/doc`

These packages are dynamically loaded only when needed to reduce CLI startup time.

Contributing

Contributions welcome! See CONTRIBUTING.md for details.

License

MIT