chore: update arguments and their descriptions for a better onboarding exp

Author: louis-jan

cortex-js/src/infrastructure/commanders/benchmark.command.ts

@@ -14,7 +14,7 @@ export class BenchmarkCommand extends CommandRunner {
   }
 
   async run(
-    _input: string[],
+    passedParams: string[],
     options?: Partial<BenchmarkConfig>,
   ): Promise<void> {
     return this.benchmarkUsecases.benchmark(options ?? {});

cortex-js/src/infrastructure/commanders/chat.command.ts

@@ -16,7 +16,16 @@ type ChatOptions = {
   attach: boolean;
 };
 
-@SubCommand({ name: 'chat', description: 'Send a chat request to a model' })
+@SubCommand({
+  name: 'chat',
+  description: 'Send a chat request to a model',
+  arguments: '[model_id] [message]',
+  argsDescription: {
+    model_id:
+      'Model ID to chat with. If there is no model_id provided, it will prompt to select from running models.',
+    message: 'Message to send to the model',
+  },
+})
 export class ChatCommand extends CommandRunner {
   constructor(
     private readonly inquirerService: InquirerService,
@@ -27,17 +36,19 @@ export class ChatCommand extends CommandRunner {
     super();
   }
 
-  async run(_input: string[], options: ChatOptions): Promise<void> {
-    let modelId = _input[0];
+  async run(passedParams: string[], options: ChatOptions): Promise<void> {
+    let modelId = passedParams[0];
     // First attempt to get message from input or options
     // Extract input from 1 to end of array
-    let message = options.message ?? _input.slice(1).join(' ');
+    let message = options.message ?? passedParams.slice(1).join(' ');
 
     // Check for model existing
     if (!modelId || !(await this.modelsUsecases.findOne(modelId))) {
       // Model ID is not provided
       // first input might be message input
-      message = _input.length ? _input.join(' ') : options.message ?? '';
+      message = passedParams.length
+        ? passedParams.join(' ')
+        : options.message ?? '';
       // If model ID is not provided, prompt user to select from running models
       const models = await this.psCliUsecases.getModels();
       if (models.length === 1) {

cortex-js/src/infrastructure/commanders/cortex-command.commander.ts

@@ -32,7 +32,10 @@ interface CortexCommandOptions {
   description: 'Cortex CLI',
 })
 export class CortexCommand extends CommandRunner {
-  async run(input: string[], option: CortexCommandOptions): Promise<void> {
+  async run(
+    passedParams: string[],
+    option: CortexCommandOptions,
+  ): Promise<void> {
     if (option.version) console.log(pkg.version);
     else this.command?.help();
   }

cortex-js/src/infrastructure/commanders/embeddings.command.ts

@@ -18,7 +18,12 @@ interface EmbeddingCommandOptions {
 
 @SubCommand({
   name: 'embeddings',
+  arguments: '[model_id]',
   description: 'Creates an embedding vector representing the input text.',
+  argsDescription: {
+    model_id:
+      'Model to use for embedding. If not provided, it will prompt to select from running models.',
+  },
 })
 export class EmbeddingCommand extends CommandRunner {
   constructor(
@@ -29,16 +34,19 @@ export class EmbeddingCommand extends CommandRunner {
   ) {
     super();
   }
-  async run(_input: string[], options: EmbeddingCommandOptions): Promise<void> {
-    let modelId = _input[0];
+  async run(
+    passedParams: string[],
+    options: EmbeddingCommandOptions,
+  ): Promise<void> {
+    let modelId = passedParams[0];
     // First attempt to get message from input or options
-    let input: string | string[] = options.input ?? _input.splice(1);
+    let input: string | string[] = options.input ?? passedParams.splice(1);
 
     // Check for model existing
     if (!modelId || !(await this.modelsUsecases.findOne(modelId))) {
       // Model ID is not provided
       // first input might be message input
-      input = _input ?? options.input;
+      input = passedParams ?? options.input;
       // If model ID is not provided, prompt user to select from running models
       const models = await this.psCliUsecases.getModels();
       if (models.length === 1) {

cortex-js/src/infrastructure/commanders/init.command.ts

@@ -10,7 +10,11 @@ import { InitOptions } from './types/init-options.interface';
 @SubCommand({
   name: 'init',
   aliases: ['setup'],
+  arguments: '[version]',
   description: "Init settings and download cortex's dependencies",
+  argsDescription: {
+    version: 'Version of cortex engine',
+  },
 })
 export class InitCommand extends CommandRunner {
   constructor(
@@ -20,16 +24,19 @@ export class InitCommand extends CommandRunner {
     super();
   }
 
-  async run(input: string[], options?: InitOptions): Promise<void> {
+  async run(passedParams: string[], options?: InitOptions): Promise<void> {
     if (options?.silent) {
-      return this.initSilently(input);
+      return this.initSilently(passedParams);
     } else {
-      return this.initPrompts(input, options);
+      return this.initPrompts(passedParams, options);
     }
   }
 
-  private initSilently = async (input: string[], options: InitOptions = {}) => {
-    const version = input[0] ?? 'latest';
+  private initSilently = async (
+    passedParams: string[],
+    options: InitOptions = {},
+  ) => {
+    const version = passedParams[0] ?? 'latest';
     if (process.platform === 'darwin') {
       const engineFileName = this.initUsecases.parseEngineFileName(options);
       return this.initUsecases.installEngine(engineFileName, version);

cortex-js/src/infrastructure/commanders/models/model-get.command.ts

@@ -2,19 +2,26 @@ import { CommandRunner, SubCommand } from 'nest-commander';
 import { ModelsCliUsecases } from '@commanders/usecases/models.cli.usecases';
 import { exit } from 'node:process';
 
-@SubCommand({ name: 'get', description: 'Get a model by ID.' })
+@SubCommand({
+  name: 'get',
+  description: 'Get a model by ID.',
+  arguments: '<model_id>',
+  argsDescription: {
+    model_id: 'Model ID to get information about.',
+  },
+})
 export class ModelGetCommand extends CommandRunner {
   constructor(private readonly modelsCliUsecases: ModelsCliUsecases) {
     super();
   }
 
-  async run(input: string[]): Promise<void> {
-    if (input.length === 0) {
+  async run(passedParams: string[]): Promise<void> {
+    if (passedParams.length === 0) {
       console.error('Model ID is required');
       exit(1);
     }
 
-    const model = await this.modelsCliUsecases.getModel(input[0]);
+    const model = await this.modelsCliUsecases.getModel(passedParams[0]);
     if (!model) console.error('Model not found');
     else console.log(model);
   }

cortex-js/src/infrastructure/commanders/models/model-list.command.ts

@@ -10,7 +10,7 @@ export class ModelListCommand extends CommandRunner {
     super();
   }
 
-  async run(_input: string[], option: ModelListOptions): Promise<void> {
+  async run(passedParams: string[], option: ModelListOptions): Promise<void> {
     const models = await this.modelsCliUsecases.listAllModels();
     option.format === 'table'
       ? console.table(

cortex-js/src/infrastructure/commanders/models/model-pull.command.ts

@@ -6,25 +6,29 @@ import { ModelNotFoundException } from '@/infrastructure/exception/model-not-fou
 @SubCommand({
   name: 'pull',
   aliases: ['download'],
+  arguments: '<model_id>',
+  argsDescription: { model_id: 'Model repo to pull' },
   description: 'Download a model. Working with HuggingFace model id.',
 })
 export class ModelPullCommand extends CommandRunner {
   constructor(private readonly modelsCliUsecases: ModelsCliUsecases) {
     super();
   }
 
-  async run(input: string[]) {
-    if (input.length < 1) {
+  async run(passedParams: string[]) {
+    if (passedParams.length < 1) {
       console.error('Model Id is required');
       exit(1);
     }
 
-    await this.modelsCliUsecases.pullModel(input[0]).catch((e: Error) => {
-      if (e instanceof ModelNotFoundException)
-        console.error('Model does not exist.');
-      else console.error(e);
-      exit(1);
-    });
+    await this.modelsCliUsecases
+      .pullModel(passedParams[0])
+      .catch((e: Error) => {
+        if (e instanceof ModelNotFoundException)
+          console.error('Model does not exist.');
+        else console.error(e);
+        exit(1);
+      });
 
     console.log('\nDownload complete!');
     exit(0);

cortex-js/src/infrastructure/commanders/models/model-remove.command.ts

@@ -2,18 +2,25 @@ import { CommandRunner, SubCommand } from 'nest-commander';
 import { ModelsCliUsecases } from '@commanders/usecases/models.cli.usecases';
 import { exit } from 'node:process';
 
-@SubCommand({ name: 'remove', description: 'Remove a model by ID locally.' })
+@SubCommand({
+  name: 'remove',
+  description: 'Remove a model by ID locally.',
+  arguments: '<model_id>',
+  argsDescription: {
+    model_id: 'Model to remove',
+  },
+})
 export class ModelRemoveCommand extends CommandRunner {
   constructor(private readonly modelsCliUsecases: ModelsCliUsecases) {
     super();
   }
 
-  async run(input: string[]): Promise<void> {
-    if (input.length === 0) {
+  async run(passedParams: string[]): Promise<void> {
+    if (passedParams.length === 0) {
       console.error('Model ID is required');
       exit(1);
     }
 
-    await this.modelsCliUsecases.removeModel(input[0]).then(console.log);
+    await this.modelsCliUsecases.removeModel(passedParams[0]).then(console.log);
   }
 }

cortex-js/src/infrastructure/commanders/models/model-start.command.ts

@@ -12,7 +12,15 @@ type ModelStartOptions = {
   attach: boolean;
   preset?: string;
 };
-@SubCommand({ name: 'start', description: 'Start a model by ID.' })
+@SubCommand({
+  name: 'start',
+  description: 'Start a model by ID.',
+  arguments: '[model_id]',
+  argsDescription: {
+    model_id:
+      'Model ID to start. If there is no model ID, it will prompt you to select from the available models.',
+  },
+})
 export class ModelStartCommand extends CommandRunner {
   constructor(
     private readonly inquirerService: InquirerService,
@@ -22,8 +30,8 @@ export class ModelStartCommand extends CommandRunner {
     super();
   }
 
-  async run(input: string[], options: ModelStartOptions): Promise<void> {
-    let modelId = input[0];
+  async run(passedParams: string[], options: ModelStartOptions): Promise<void> {
+    let modelId = passedParams[0];
     if (!modelId) {
       try {
         modelId = await this.modelInquiry();