@cyberismo/cli 0.0.17 → 0.0.19

package/src/index.ts

@@ -12,7 +12,8 @@
   License along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
-import { readFile } from 'node:fs/promises';
+import { constants, existsSync } from 'node:fs';
+import { access, lstat, readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
 import { Argument, Command, Option } from 'commander';
@@ -138,62 +139,6 @@ const nameGuideline =
 const pathGuideline =
   'Path to the project root. Mandatory if not running inside a project tree.';
 
-const additionalHelpForCreate = `Sub-command help:
-  create attachment <cardKey> <filename>, where
-      <cardKey> is card key of a card to have the attachment,
-      <filename> is attachment filename.
-
-  create card <template> [cardKey], where
-      <template> Template to use. You can list the templates in a project with "show templates" command.
-      [cardKey] Parent card's card key. If defined, new card will be created as a child card to that card.
-
-  create cardType <name> <workflow>, where
-      <name> Name for cardType. ${nameGuideline}
-      <workflow> Workflow for the card type. You can list workflows in a project with "show workflows" command.
-
-  create fieldType <name> <dataType>, where
-      <name> Name for fieldType. ${nameGuideline}
-      <dataType> Type of field. You can list field types in a project with "show fieldTypes" command.
-
-  create graphModel <name>, where
-      <name> Name for graph model. ${nameGuideline}
-
-  create graphView <name>, where
-      <name> Name for graph view. ${nameGuideline}
-
-  create label <cardKey> <labelName>, where
-      <cardKey> Card key of the label
-      <labelName> Name for the new label
-
-  create link <source> <destination> <linkType> [description], where
-      <source> Source card key of the link
-      <destination> Destination card key of the link
-      <linkType> Link type to create
-      [description] Link description
-
-  create linkType <name>, where
-      <name> Name for linkType. ${nameGuideline}
-
-  create project <name> <prefix> <path>, where
-      <name> Name of the project.
-      <prefix> Prefix for the project.
-      <path> Path where to create the project
-
-  create report <name>, where
-      <name> Name for report. ${nameGuideline}
-
-  create template <name> [content], where
-      <name> Name for template. ${nameGuideline}
-      [content] If empty, template is created with default values. Template content must conform to schema "templateSchema.json"
-
-  create workflow <name> [content], where
-      <name> Name for workflow. ${nameGuideline}
-      [content] If empty, workflow is created with default values. Workflow content must conform to schema "workflowSchema.json"
-
-  create <resourceName> [content], where
-      <resourceName> Name of the resource (e.g. <prefix>/<type>/<identifier>)
-      [content] If empty, resource is created with default values. Content must conform to its resource schema.`;
-
 const additionalHelpForRemove = `Sub-command help:
   remove attachment <cardKey> <filename>, where
       <cardKey> is card key of the owning card,
@@ -256,6 +201,20 @@ const contextOption = new Option(
   .choices(validContexts)
   .default('app');
 
+const pathOption = new Option('-p, --project-path <path>', pathGuideline);
+
+// Custom Command class with pathOption pre-configured
+class CommandWithPath extends Command {
+  createCommand(name?: string): CommandWithPath {
+    return new CommandWithPath(name);
+  }
+
+  constructor(name?: string) {
+    super(name);
+    this.addOption(pathOption);
+  }
+}
+
 // Main CLI program.
 program
   .name('cyberismo')
@@ -272,7 +231,10 @@ program
       .default('fatal'),
   );
 
-const addCmd = program.command('add').description('Add items to the project');
+const addCmd = new CommandWithPath('add').description(
+  'Add items to the project',
+);
+program.addCommand(addCmd);
 
 // Add card to a template
 addCmd
@@ -287,7 +249,6 @@ addCmd
     'Card type to use for the new card. \nYou can list the card types in a project with "show cardTypes" command.',
   )
   .argument('[cardKey]', "Parent card's card key")
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .option('-r, --repeat <quantity>', 'Add multiple cards to a template')
   .action(
     async (
@@ -312,7 +273,6 @@ addCmd
     '<location>',
     'Hub URL. Default hub can be added by using "default"',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(async (location: string, options: CommandOptions<'add'>) => {
     if (location === 'default') {
       location = DEFAULT_HUB;
@@ -325,9 +285,10 @@ addCmd
     handleResponse(result);
   });
 
-const calculate = program
-  .command('calc')
-  .description('Used for running logic programs');
+const calculate = new CommandWithPath('calc').description(
+  'Used for running logic programs',
+);
+program.addCommand(calculate);
 
 calculate
   .command('generate')
@@ -337,7 +298,6 @@ calculate
     'Path to an output file. Command writes the logic program to this file.',
   )
   .argument('[query]', 'Query to run')
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(
     async (
       destination: string,
@@ -358,7 +318,6 @@ calculate
   .description('Run a logic program')
   .argument('<filePath>', 'Path to the logic program')
   .addOption(contextOption)
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(async (filePath: string, options: CommandOptions<'calc'>) => {
     const result = await commandHandler.command(
       Cmd.calc,
@@ -368,120 +327,231 @@ calculate
     handleResponse(result);
   });
 
-program
-  .command('create')
-  .description('Create cards, resources and other project items')
-  .argument(
-    '<type>',
-    `types to create: '${Parser.listTargets('create').join("', '")}', or resource name (e.g. <prefix>/<type>/<identifier>)`,
-    Parser.parseCreateTypes,
-  )
+const createCmd = new CommandWithPath('create').description(
+  'Create cards, resources and other project items',
+);
+program.addCommand(createCmd);
+
+// Create attachment subcommand
+createCmd
+  .command('attachment')
+  .description('Create an attachment for a card')
+  .argument('<cardKey>', 'Card key of the card to attach to')
+  .argument('<filename>', 'Path to the file to attach')
+  .action(
+    async (
+      cardKey: string,
+      filename: string,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['attachment', cardKey, filename],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
+
+// Create card subcommand
+createCmd
+  .command('card')
+  .description('Create a card from a template')
   .argument(
-    '[target]',
-    'Name to create, or in some operations cardKey to create data to a specific card. See below',
+    '<template>',
+    'Template to use. You can list templates with "show templates" command',
   )
   .argument(
-    '[parameter1]',
-    'Depends on context; see below for specific remove operation',
+    '[parentCardKey]',
+    "Parent card's card key. If defined, new card will be created as a child",
   )
+  .action(
+    async (
+      template: string,
+      parentCardKey: string | undefined,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['card', template, parentCardKey].filter(Boolean) as string[],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
+
+// Create cardType subcommand
+createCmd
+  .command('cardType')
+  .description('Create a new card type')
+  .argument('<name>', `Name for card type. ${nameGuideline}`)
   .argument(
-    '[parameter2]',
-    'Depends on context; see below for specific remove operation',
+    '<workflow>',
+    'Workflow for the card type. You can list workflows with "show workflows" command',
   )
+  .action(
+    async (
+      name: string,
+      workflow: string,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['cardType', name, workflow],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
+
+// Create fieldType subcommand
+createCmd
+  .command('fieldType')
+  .description('Create a new field type')
+  .argument('<name>', `Name for field type. ${nameGuideline}`)
   .argument(
-    '[parameter3]',
-    'Depends on context; see below for specific remove operation',
-  )
-  .addHelpText('after', additionalHelpForCreate)
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .option(
-    '-s, --skipModuleImport',
-    'Skip importing modules when creating a project',
+    '<dataType>',
+    'Type of field. You can list field types with "show fieldTypes" command',
   )
   .action(
     async (
-      type: string,
-      target: string,
-      parameter1: string,
-      parameter2: string,
-      parameter3: string,
+      name: string,
+      dataType: string,
       options: CommandOptions<'create'>,
     ) => {
-      if (!type) {
-        program.error(`missing required argument <type>`);
-      }
-
-      const resourceName: boolean = type.split('/').length === 3;
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['fieldType', name, dataType],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
 
-      function nameOfFirstArgument(type: string) {
-        if (type === 'attachment' || type === 'label') return 'cardKey';
-        if (type === 'card') return 'template';
-        if (type === 'link') return 'source';
-        return 'name';
-      }
+// Create graphModel subcommand
+createCmd
+  .command('graphModel')
+  .description('Create a new graph model')
+  .argument('<name>', `Name for graph model. ${nameGuideline}`)
+  .action(async (name: string, options: CommandOptions<'create'>) => {
+    const result = await commandHandler.command(
+      Cmd.create,
+      ['graphModel', name],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  });
 
-      function nameOfSecondArgument(type: string) {
-        if (type === 'attachment') return 'fileName';
-        if (type === 'cardType') return 'workflow';
-        if (type === 'fieldType') return 'dataType';
-        if (type === 'label') return 'labelName';
-        if (type === 'link') return 'destination';
-        if (type === 'project') return 'prefix';
-        return type;
-      }
+// Create graphView subcommand
+createCmd
+  .command('graphView')
+  .description('Create a new graph view')
+  .argument('<name>', `Name for graph view. ${nameGuideline}`)
+  .action(async (name: string, options: CommandOptions<'create'>) => {
+    const result = await commandHandler.command(
+      Cmd.create,
+      ['graphView', name],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  });
 
-      if (!target && !resourceName) {
-        program.error(
-          `missing required argument <${nameOfFirstArgument(type)}>`,
-        );
-      }
+// Create label subcommand
+createCmd
+  .command('label')
+  .description('Create a label on a card')
+  .argument('<cardKey>', 'Card key')
+  .argument('<labelName>', 'Name for the new label')
+  .action(
+    async (
+      cardKey: string,
+      labelName: string,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['label', cardKey, labelName],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
 
-      if (
-        !resourceName &&
-        !parameter1 &&
-        type !== 'card' &&
-        type !== 'graphModel' &&
-        type !== 'graphView' &&
-        type !== 'linkType' &&
-        type !== 'report' &&
-        type !== 'template' &&
-        type !== 'workflow'
-      ) {
-        program.error(
-          `missing required argument <${nameOfSecondArgument(type)}>`,
-        );
-      }
+// Create link subcommand
+createCmd
+  .command('link')
+  .description('Create a link between two cards')
+  .argument('<source>', 'Source card key')
+  .argument('<destination>', 'Destination card key')
+  .argument('<linkType>', 'Link type to create')
+  .argument('[description]', 'Optional link description')
+  .action(
+    async (
+      source: string,
+      destination: string,
+      linkType: string,
+      description: string | undefined,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['link', source, destination, linkType, description].filter(
+          Boolean,
+        ) as string[],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
 
-      if (
-        resourceName &&
-        (type.includes('cardTypes') || type.includes('fieldTypes')) &&
-        !target
-      ) {
-        program.error(
-          `missing required argument <${nameOfSecondArgument(type)}>`,
-        );
-      }
+// Create linkType subcommand
+createCmd
+  .command('linkType')
+  .description('Create a new link type')
+  .argument('<name>', `Name for link type. ${nameGuideline}`)
+  .action(async (name: string, options: CommandOptions<'create'>) => {
+    const result = await commandHandler.command(
+      Cmd.create,
+      ['linkType', name],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  });
 
-      if (type === 'project') {
-        if (!parameter2) {
-          program.error(`missing required argument <path>`);
-        }
-        // Project path must be set to 'options' when creating a project.
-        options.projectPath = parameter2;
-      }
+// Create project subcommand
+createCmd
+  .command('project')
+  .description('Create a new project')
+  .argument('<name>', 'Project name')
+  .argument('<prefix>', 'Project prefix')
+  .argument('<path>', 'Path where to create the project')
+  .argument('[category]', 'Project category (optional)')
+  .argument('[description]', 'Project description (optional)')
+  .option(
+    '-s, --skipModuleImport',
+    'Skip importing modules when creating a project',
+  )
+  .action(
+    async (
+      name: string,
+      prefix: string,
+      path: string,
+      category: string | undefined,
+      description: string | undefined,
+      options: CommandOptions<'create'>,
+    ) => {
+      // Project path must be set to 'options' when creating a project
+      options.projectPath = path;
       const commandOptions = Object.assign({}, options, program.opts());
+
       const result = await commandHandler.command(
         Cmd.create,
-        [type, target, parameter1, parameter2, parameter3],
+        ['project', name, prefix, path, category || '', description || ''],
         commandOptions,
       );
 
-      // Post-handling after creating a new project.
-      if (
-        type === 'project' &&
-        !commandOptions.skipModuleImport &&
-        result.statusCode === 200
-      ) {
+      // Post-handling after creating a new project
+      if (!commandOptions.skipModuleImport && result.statusCode === 200) {
         try {
           // add default hub
           await commandHandler.command(
@@ -528,25 +598,115 @@ program
     },
   );
 
-// Edit command
-program
-  .command('edit')
-  .description('Edit a card')
-  .argument('<cardKey>', 'Card key of card')
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(async (cardKey: string, options: CommandOptions<'edit'>) => {
+// Create report subcommand
+createCmd
+  .command('report')
+  .description('Create a new report')
+  .argument('<name>', `Name for report. ${nameGuideline}`)
+  .action(async (name: string, options: CommandOptions<'create'>) => {
     const result = await commandHandler.command(
-      Cmd.edit,
-      [cardKey],
+      Cmd.create,
+      ['report', name],
       Object.assign({}, options, program.opts()),
     );
     handleResponse(result);
   });
 
+// Create template subcommand
+createCmd
+  .command('template')
+  .description('Create a new template')
+  .argument('<name>', `Name for template. ${nameGuideline}`)
+  .argument(
+    '[content]',
+    'Template content. If empty, template is created with default values. Must conform to templateSchema.json',
+  )
+  .action(
+    async (
+      name: string,
+      content: string | undefined,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['template', name, content].filter(Boolean) as string[],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
+
+// Create workflow subcommand
+createCmd
+  .command('workflow')
+  .description('Create a new workflow')
+  .argument('<name>', `Name for workflow. ${nameGuideline}`)
+  .argument(
+    '[content]',
+    'Workflow content. If empty, workflow is created with default values. Must conform to workflowSchema.json',
+  )
+  .action(
+    async (
+      name: string,
+      content: string | undefined,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        ['workflow', name, content].filter(Boolean) as string[],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
+
+// Create new resource subcommand
+createCmd
+  .command('resource')
+  .description('Create a new resource')
+  .argument(
+    '<resourceName>',
+    'Resource name (e.g. <prefix>/<type>/<identifier>)',
+  )
+  .argument(
+    '[content]',
+    'Resource content. If empty, resource is created with default values. Must conform to its resource schema',
+  )
+  .action(
+    async (
+      resourceName: string,
+      content: string | undefined,
+      options: CommandOptions<'create'>,
+    ) => {
+      const result = await commandHandler.command(
+        Cmd.create,
+        [resourceName, content].filter(Boolean) as string[],
+        Object.assign({}, options, program.opts()),
+      );
+      handleResponse(result);
+    },
+  );
+
+// Edit command
+const editCmd = new CommandWithPath('edit')
+  .description('Edit a card')
+  .argument('<cardKey>', 'Card key of card');
+program.addCommand(editCmd);
+editCmd.action(async (cardKey: string, options: CommandOptions<'edit'>) => {
+  const result = await commandHandler.command(
+    Cmd.edit,
+    [cardKey],
+    Object.assign({}, options, program.opts()),
+  );
+  handleResponse(result);
+});
+
 // Export command
-program
-  .command('export')
-  .description('Export a project or a card')
+const exportCmd = new CommandWithPath('export').description(
+  'Export a project or a card',
+);
+program.addCommand(exportCmd);
+exportCmd
   .addArgument(
     new Argument('<format>', 'Export format').choices(
       Object.values(ExportFormats),
@@ -557,7 +717,6 @@ program
     '[cardKey]',
     'Export a specific card by card key. If omitted, exports the whole site.',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .option(
     '-r, --recursive',
     'Export cards under the specified card recursively',
@@ -637,15 +796,14 @@ program
     },
   );
 
-const fetchCmd = program
-  .command('fetch')
-  .description('Retrieve external data to local file system.')
-  .option('-p, --project-path [path]', `${pathGuideline}`);
+const fetchCmd = new CommandWithPath('fetch').description(
+  'Retrieve external data to local file system.',
+);
+program.addCommand(fetchCmd);
 
 fetchCmd
   .command('hubs')
   .description('Retrieves module lists from hubs')
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(async (options: CommandOptions<'fetch'>) => {
     const result = await commandHandler.command(
       Cmd.fetch,
@@ -655,10 +813,10 @@ fetchCmd
     handleResponse(result);
   });
 
-const importCmd = program
-  .command('import')
-  .description('Import modules and data into the project')
-  .option('-p, --project-path [path]', `${pathGuideline}`);
+const importCmd = new CommandWithPath('import').description(
+  'Import modules and data into the project',
+);
+program.addCommand(importCmd);
 
 // Import module
 importCmd
@@ -675,7 +833,6 @@ importCmd
     '[useCredentials]',
     'When using git URL uses credentials for cloning. Default: false',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(
     async (
       source: string,
@@ -763,9 +920,8 @@ importCmd
   .argument('<csvFile>', 'File to import from')
   .argument(
     '[cardKey]',
-    'Card key of the parent. If defined, cards are created as children of this card',
+    'Parent card key. If defined, cards are created as children of this card',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(
     async (
       csvFile: string,
@@ -781,9 +937,80 @@ importCmd
     },
   );
 
-// Move command
+// Migrate command
 program
-  .command('move')
+  .command('migrate')
+  .description('Migrate project schema to a newer version.')
+  .argument(
+    '[version]',
+    'Target schema version. If not provided, migrates to the latest version. Can only migrate one version at a time when specified.',
+  )
+  .option('-p, --project-path [path]', `${pathGuideline}`)
+  .option(
+    '-b, --backup <directory>',
+    'Create a backup before migration in the specified directory. Directory must exist.',
+  )
+  .option(
+    '-t, --timeout <minutes>',
+    'Timeout for migration in minutes (default: 2 minutes)',
+    '2',
+  )
+  .action(async (version: string, options: CommandOptions<'migrate'>) => {
+    if (version) {
+      const versionNumber = parseInt(version);
+      if (isNaN(versionNumber)) {
+        console.error(`Error: migration version is not a number: '${version}'`);
+        process.exit(1);
+      }
+      if (versionNumber <= 0) {
+        console.error(
+          `Error: migration version must be above zero: '${version}'`,
+        );
+        process.exit(1);
+      }
+      if (options.backup) {
+        options.backup = resolve(options.backup.toString().trim());
+        if (!existsSync(options.backup)) {
+          console.error(
+            `Error: Backup directory does not exist: ${options.backup}`,
+          );
+          process.exit(1);
+        }
+        try {
+          await access(options.backup, constants.W_OK);
+        } catch {
+          console.error(
+            `Error: Cannot write to backup directory: ${options.backup}`,
+          );
+          process.exit(1);
+        }
+        if (!(await lstat(options.backup)).isDirectory()) {
+          console.error(`Error: Backup directory is a file: ${options.backup}`);
+          process.exit(1);
+        }
+      }
+    }
+
+    if (options.timeout !== undefined) {
+      const timeoutMinutes = Number(options.timeout);
+      if (isNaN(timeoutMinutes) || timeoutMinutes <= 0) {
+        console.error(`Error: Timeout must be a positive number`);
+        process.exit(1);
+      }
+      // Convert minutes to milliseconds
+      options.timeout = timeoutMinutes * 60 * 1000;
+    }
+
+    const result = await commandHandler.command(
+      Cmd.migrate,
+      [version],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  });
+
+// Move command
+const moveCmd = new CommandWithPath('move')
   .description(
     'Moves a card from root to under another card, from under another card to root, or from under a one card to another.',
   )
@@ -791,22 +1018,22 @@ program
   .argument(
     '[destination]',
     'Destination Card key where "source" is moved to. If moving to root, use "root"',
-  )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(
-    async (
-      source: string,
-      destination: string,
-      options: CommandOptions<'move'>,
-    ) => {
-      const result = await commandHandler.command(
-        Cmd.move,
-        [source, destination],
-        Object.assign({}, options, program.opts()),
-      );
-      handleResponse(result);
-    },
   );
+program.addCommand(moveCmd);
+moveCmd.action(
+  async (
+    source: string,
+    destination: string,
+    options: CommandOptions<'move'>,
+  ) => {
+    const result = await commandHandler.command(
+      Cmd.move,
+      [source, destination],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  },
+);
 
 program
   .command('preview')
@@ -819,10 +1046,10 @@ program
     await previewSite(dir || '.', true);
   });
 
-const rank = program
-  .command('rank')
-  .description('Manage card ranking and ordering')
-  .option('-p, --project-path [path]', `${pathGuideline}`);
+const rank = new CommandWithPath('rank').description(
+  'Manage card ranking and ordering',
+);
+program.addCommand(rank);
 
 rank
   .command('card')
@@ -834,7 +1061,6 @@ rank
     '<afterCardKey>',
     'Card key of the card that the card should be after. Use "first" to rank the card first.',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(
     async (
       cardKey: string,
@@ -857,9 +1083,8 @@ rank
   )
   .argument(
     '[parentCardKey]',
-    'if null, rebalance the whole project, otherwise rebalance only the direct children of the card key',
+    'if null, rebalance the whole project, otherwise rebalance only the direct children',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(async (cardKey: string, options: CommandOptions<'rank'>) => {
     const result = await commandHandler.command(
       Cmd.rank,
@@ -870,9 +1095,11 @@ rank
   });
 
 // Remove command
-program
-  .command('remove')
-  .description('Remove cards, resources and other project items')
+const removeCmd = new CommandWithPath('remove').description(
+  'Remove cards, resources and other project items',
+);
+program.addCommand(removeCmd);
+removeCmd
   .argument(
     '<type>',
     `removable types: '${Parser.listTargets('remove').join("', '")}', or resource name (e.g. <prefix>/<type>/<identifier>)`,
@@ -891,7 +1118,6 @@ program
     'Depends on context; see below for specific remove operation',
   )
   .addHelpText('after', additionalHelpForRemove)
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .action(
     async (
       type: string,
@@ -942,25 +1168,23 @@ program
   );
 
 // Rename command
-program
-  .command('rename')
+const renameCmd = new CommandWithPath('rename')
   .description(
     'Change project prefix and rename all the content with the new prefix',
   )
-  .argument('<to>', 'New project prefix')
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(async (to: string, options: CommandOptions<'rename'>) => {
-    const result = await commandHandler.command(
-      Cmd.rename,
-      [to],
-      Object.assign({}, options, program.opts()),
-    );
-    handleResponse(result);
-  });
+  .argument('<to>', 'New project prefix');
+program.addCommand(renameCmd);
+renameCmd.action(async (to: string, options: CommandOptions<'rename'>) => {
+  const result = await commandHandler.command(
+    Cmd.rename,
+    [to],
+    Object.assign({}, options, program.opts()),
+  );
+  handleResponse(result);
+});
 
 // Report command
-program
-  .command('report')
+const reportCmd = new CommandWithPath('report')
   .description('Runs a report')
   .argument(
     '<parameters>',
@@ -970,27 +1194,29 @@ program
     '[output]',
     'Optional output file; if omitted output will be directed to stdout',
   )
-  .addOption(contextOption)
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(
-    async (
-      parameters: string,
-      output: string,
-      options: CommandOptions<'report'>,
-    ) => {
-      const result = await commandHandler.command(
-        Cmd.report,
-        [parameters, output],
-        Object.assign({}, options, program.opts()),
-      );
-      handleResponse(result);
-    },
-  );
+  .addOption(contextOption);
+program.addCommand(reportCmd);
+reportCmd.action(
+  async (
+    parameters: string,
+    output: string,
+    options: CommandOptions<'report'>,
+  ) => {
+    const result = await commandHandler.command(
+      Cmd.report,
+      [parameters, output],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  },
+);
 
 // Show command
-program
-  .command('show')
-  .description('Shows details from a project')
+const showCmd = new CommandWithPath('show').description(
+  'Shows details from a project',
+);
+program.addCommand(showCmd);
+showCmd
   .argument(
     '<type>',
     `details can be seen from: ${Parser.listTargets('show').join(', ')}`,
@@ -1008,7 +1234,6 @@ program
     '-a --showAll',
     'Show all modules, irregardless if it has been imported or not. Only with "show importableModules"',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .option(
     '-u --show-use',
     'Show where resource is used. Only used with resources, otherwise will be ignored.',
@@ -1035,34 +1260,35 @@ program
   });
 
 // Transition command
-program
-  .command('transition')
+const transitionCmd = new CommandWithPath('transition')
   .description('Transition a card to the specified state')
   .argument('<cardKey>', 'card key of a card')
   .argument(
     '<transition>',
     'Workflow state transition that is done.\nYou can list the workflows in a project with "show workflows" command.\nYou can see the available transitions with "show workflow <name>" command.',
-  )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(
-    async (
-      cardKey: string,
-      transition: string,
-      options: CommandOptions<'transition'>,
-    ) => {
-      const result = await commandHandler.command(
-        Cmd.transition,
-        [cardKey, transition],
-        Object.assign({}, options, program.opts()),
-      );
-      handleResponse(result);
-    },
   );
+program.addCommand(transitionCmd);
+transitionCmd.action(
+  async (
+    cardKey: string,
+    transition: string,
+    options: CommandOptions<'transition'>,
+  ) => {
+    const result = await commandHandler.command(
+      Cmd.transition,
+      [cardKey, transition],
+      Object.assign({}, options, program.opts()),
+    );
+    handleResponse(result);
+  },
+);
 
 // Update command
-program
-  .command('update')
-  .description('Update resource details')
+const updateCmd = new CommandWithPath('update').description(
+  'Update resource details',
+);
+program.addCommand(updateCmd);
+updateCmd
   .argument('<resourceName>', 'Resource name')
   .argument(
     '<operation>',
@@ -1075,10 +1301,9 @@ program
     'When using "change" define new value for detail.\nWhen using "remove" provide optional replacement value for removed value',
   )
   .option(
-    '-m, --mapping-file [path]',
+    '-m, --mapping-file <path>',
     'Path to JSON file containing workflow state mapping (only used when changing workflow)',
   )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
   .addHelpText('after', additionalHelpForUpdate)
   .action(
     async (
@@ -1099,14 +1324,14 @@ program
   );
 
 // Updates all modules, or specific named module in the project.
-program
-  .command('update-modules')
+const updateModulesCmd = new CommandWithPath('update-modules')
   .description(
     'Updates to latest versions either all modules or a specific module',
   )
-  .argument('[moduleName]', 'Module name')
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(async (moduleName, options: CommandOptions<'updateModules'>) => {
+  .argument('[moduleName]', 'Module name');
+program.addCommand(updateModulesCmd);
+updateModulesCmd.action(
+  async (moduleName, options: CommandOptions<'updateModules'>) => {
     const result = await commandHandler.command(
       Cmd.updateModules,
       [moduleName],
@@ -1114,66 +1339,66 @@ program
       credentials(),
     );
     handleResponse(result);
-  });
+  },
+);
 
 // Validate command
-program
-  .command('validate')
-  .description('Validate project structure')
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(async (options: CommandOptions<'validate'>) => {
-    const result = await commandHandler.command(
-      Cmd.validate,
-      [],
-      Object.assign({}, options, program.opts()),
-    );
-    handleResponse(result);
-  });
+const validateCmd = new CommandWithPath('validate').description(
+  'Validate project structure',
+);
+program.addCommand(validateCmd);
+validateCmd.action(async (options: CommandOptions<'validate'>) => {
+  const result = await commandHandler.command(
+    Cmd.validate,
+    [],
+    Object.assign({}, options, program.opts()),
+  );
+  handleResponse(result);
+});
 
 // Start app command.
 // If there are validation errors, user is prompted to continue or not.
 // There is 10 sec timeout on the prompt. If user does not reply, then
 // it is assumed that validation errors do not matter and application
 // start is resumed.
-program
-  .command('app')
+const appCmd = new CommandWithPath('app')
   .description(
     'Starts the cyberismo app, accessible with a web browser at http://localhost:3000',
   )
   .option(
     '-w, --watch-resource-changes',
     'Project watches changes in .cards folder resources',
-  )
-  .option('-p, --project-path [path]', `${pathGuideline}`)
-  .action(async (options: CommandOptions<'start'>) => {
-    // validate project
-    const result = await commandHandler.command(
-      Cmd.validate,
-      [],
-      Object.assign({}, options, program.opts()),
-    );
-    if (!result.message) {
-      program.error('Expected validation result, but got none');
+  );
+program.addCommand(appCmd);
+appCmd.action(async (options: CommandOptions<'start'>) => {
+  // validate project
+  const result = await commandHandler.command(
+    Cmd.validate,
+    [],
+    Object.assign({}, options, program.opts()),
+  );
+  if (!result.message) {
+    program.error('Expected validation result, but got none');
+    return;
+  }
+  if (result.message !== 'Project structure validated') {
+    truncateMessage(result.message).forEach((item) => console.error(item));
+    console.error('\n'); // The output looks nicer with one extra row.
+    result.message = '';
+    const userConfirmation = await confirm(
+      {
+        message: 'There are validation errors. Do you want to continue?',
+      },
+      { signal: AbortSignal.timeout(10000), clearPromptOnDone: true },
+    ).catch((error) => {
+      return error.name === 'AbortPromptError';
+    });
+    if (!userConfirmation) {
+      handleResponse(result);
       return;
     }
-    if (result.message !== 'Project structure validated') {
-      truncateMessage(result.message).forEach((item) => console.error(item));
-      console.error('\n'); // The output looks nicer with one extra row.
-      result.message = '';
-      const userConfirmation = await confirm(
-        {
-          message: 'There are validation errors. Do you want to continue?',
-        },
-        { signal: AbortSignal.timeout(10000), clearPromptOnDone: true },
-      ).catch((error) => {
-        return error.name === 'AbortPromptError';
-      });
-      if (!userConfirmation) {
-        handleResponse(result);
-        return;
-      }
-    }
-    await startServer(await commandHandler.getProjectPath(options.projectPath));
-  });
+  }
+  await startServer(await commandHandler.getProjectPath(options.projectPath));
+});
 
 export default program;