@cyberismo/cli 0.0.17 → 0.0.19

package/dist/index.js

@@ -11,7 +11,8 @@
   details. You should have received a copy of the GNU Affero General Public
   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';
 import confirm from '@inquirer/confirm';
@@ -100,61 +101,6 @@ const program = new Command();
 // Ensure that all names have the same guideline.
 const nameGuideline = 'Name can contain letters (a-z|A-Z), spaces, underscores or hyphens.';
 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,
@@ -211,6 +157,17 @@ const additionalHelpForUpdate = `Sub-command help:
 const contextOption = new Option('-c, --context [context]', 'Context to run the logic programs in.')
     .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) {
+        return new CommandWithPath(name);
+    }
+    constructor(name) {
+        super(name);
+        this.addOption(pathOption);
+    }
+}
 // Main CLI program.
 program
     .name('cyberismo')
@@ -220,7 +177,8 @@ program
     .addOption(new Option('-L, --log-level <level>', 'Set the log level')
     .choices(['trace', 'debug', 'info', 'warn', 'error', 'fatal'])
     .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
     .command('card')
@@ -228,7 +186,6 @@ addCmd
     .argument('<template>', 'Template for a new card. \nYou can list the templates in a project with "show templates" command.')
     .argument('<cardType>', '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 (template, cardType, cardKey, options) => {
     const result = await commandHandler.command(Cmd.add, ['card', template, cardType, cardKey], Object.assign({}, options, program.opts()));
@@ -238,7 +195,6 @@ addCmd
     .command('hub')
     .description('Add a hub to the project')
     .argument('<location>', 'Hub URL. Default hub can be added by using "default"')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
     .action(async (location, options) => {
     if (location === 'default') {
         location = DEFAULT_HUB;
@@ -246,15 +202,13 @@ addCmd
     const result = await commandHandler.command(Cmd.add, ['hub', location], Object.assign({}, options, program.opts()));
     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')
     .description('Generate a logic program')
     .argument('<destination>', '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, query, options) => {
     const result = await commandHandler.command(Cmd.calc, ['generate', destination, query], Object.assign({}, options, program.opts()));
     handleResponse(result);
@@ -264,83 +218,118 @@ calculate
     .description('Run a logic program')
     .argument('<filePath>', 'Path to the logic program')
     .addOption(contextOption)
-    .option('-p, --project-path [path]', `${pathGuideline}`)
     .action(async (filePath, options) => {
     const result = await commandHandler.command(Cmd.calc, ['run', filePath], Object.assign({}, options, program.opts()));
     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)
-    .argument('[target]', 'Name to create, or in some operations cardKey to create data to a specific card. See below')
-    .argument('[parameter1]', 'Depends on context; see below for specific remove operation')
-    .argument('[parameter2]', 'Depends on context; see below for specific remove operation')
-    .argument('[parameter3]', 'Depends on context; see below for specific remove operation')
-    .addHelpText('after', additionalHelpForCreate)
-    .option('-p, --project-path [path]', `${pathGuideline}`)
+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, filename, options) => {
+    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('<template>', 'Template to use. You can list templates with "show templates" command')
+    .argument('[parentCardKey]', "Parent card's card key. If defined, new card will be created as a child")
+    .action(async (template, parentCardKey, options) => {
+    const result = await commandHandler.command(Cmd.create, ['card', template, parentCardKey].filter(Boolean), 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('<workflow>', 'Workflow for the card type. You can list workflows with "show workflows" command')
+    .action(async (name, workflow, options) => {
+    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('<dataType>', 'Type of field. You can list field types with "show fieldTypes" command')
+    .action(async (name, dataType, options) => {
+    const result = await commandHandler.command(Cmd.create, ['fieldType', name, dataType], Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
+// Create graphModel subcommand
+createCmd
+    .command('graphModel')
+    .description('Create a new graph model')
+    .argument('<name>', `Name for graph model. ${nameGuideline}`)
+    .action(async (name, options) => {
+    const result = await commandHandler.command(Cmd.create, ['graphModel', name], Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
+// Create graphView subcommand
+createCmd
+    .command('graphView')
+    .description('Create a new graph view')
+    .argument('<name>', `Name for graph view. ${nameGuideline}`)
+    .action(async (name, options) => {
+    const result = await commandHandler.command(Cmd.create, ['graphView', name], Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
+// 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, labelName, options) => {
+    const result = await commandHandler.command(Cmd.create, ['label', cardKey, labelName], Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
+// 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, destination, linkType, description, options) => {
+    const result = await commandHandler.command(Cmd.create, ['link', source, destination, linkType, description].filter(Boolean), Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
+// Create linkType subcommand
+createCmd
+    .command('linkType')
+    .description('Create a new link type')
+    .argument('<name>', `Name for link type. ${nameGuideline}`)
+    .action(async (name, options) => {
+    const result = await commandHandler.command(Cmd.create, ['linkType', name], Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
+// 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 (type, target, parameter1, parameter2, parameter3, options) => {
-    if (!type) {
-        program.error(`missing required argument <type>`);
-    }
-    const resourceName = type.split('/').length === 3;
-    function nameOfFirstArgument(type) {
-        if (type === 'attachment' || type === 'label')
-            return 'cardKey';
-        if (type === 'card')
-            return 'template';
-        if (type === 'link')
-            return 'source';
-        return 'name';
-    }
-    function nameOfSecondArgument(type) {
-        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;
-    }
-    if (!target && !resourceName) {
-        program.error(`missing required argument <${nameOfFirstArgument(type)}>`);
-    }
-    if (!resourceName &&
-        !parameter1 &&
-        type !== 'card' &&
-        type !== 'graphModel' &&
-        type !== 'graphView' &&
-        type !== 'linkType' &&
-        type !== 'report' &&
-        type !== 'template' &&
-        type !== 'workflow') {
-        program.error(`missing required argument <${nameOfSecondArgument(type)}>`);
-    }
-    if (resourceName &&
-        (type.includes('cardTypes') || type.includes('fieldTypes')) &&
-        !target) {
-        program.error(`missing required argument <${nameOfSecondArgument(type)}>`);
-    }
-    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;
-    }
+    .action(async (name, prefix, path, category, description, options) => {
+    // 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], commandOptions);
-    // Post-handling after creating a new project.
-    if (type === 'project' &&
-        !commandOptions.skipModuleImport &&
-        result.statusCode === 200) {
+    const result = await commandHandler.command(Cmd.create, ['project', name, prefix, path, category || '', description || ''], commandOptions);
+    // Post-handling after creating a new project
+    if (!commandOptions.skipModuleImport && result.statusCode === 200) {
         try {
             // add default hub
             await commandHandler.command(Cmd.add, ['hub', DEFAULT_HUB], commandOptions);
@@ -372,24 +361,61 @@ program
     }
     handleResponse(result);
 });
+// Create report subcommand
+createCmd
+    .command('report')
+    .description('Create a new report')
+    .argument('<name>', `Name for report. ${nameGuideline}`)
+    .action(async (name, options) => {
+    const result = await commandHandler.command(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, content, options) => {
+    const result = await commandHandler.command(Cmd.create, ['template', name, content].filter(Boolean), 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, content, options) => {
+    const result = await commandHandler.command(Cmd.create, ['workflow', name, content].filter(Boolean), 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, content, options) => {
+    const result = await commandHandler.command(Cmd.create, [resourceName, content].filter(Boolean), Object.assign({}, options, program.opts()));
+    handleResponse(result);
+});
 // Edit command
-program
-    .command('edit')
+const editCmd = new CommandWithPath('edit')
     .description('Edit a card')
-    .argument('<cardKey>', 'Card key of card')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
-    .action(async (cardKey, options) => {
+    .argument('<cardKey>', 'Card key of card');
+program.addCommand(editCmd);
+editCmd.action(async (cardKey, options) => {
     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)))
     .argument('<output>', 'Output path')
     .argument('[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')
     .option('-t, --title [title]', 'Title of the exported document(pdf export only)')
     .option('-n, --name [name]', 'Name of the exported document(pdf export only)')
@@ -436,22 +462,17 @@ program
     const result = await commandHandler.command(Cmd.export, [format, output, cardKey], Object.assign({}, options, program.opts()));
     handleResponse(result);
 });
-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) => {
     const result = await commandHandler.command(Cmd.fetch, ['hubs'], Object.assign({}, options, program.opts()));
     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
     .command('module')
@@ -459,7 +480,6 @@ importCmd
     .argument('[source]', 'Path to import from or module name. If omitted, shows interactive selection')
     .argument('[branch]', 'When using git URL defines the branch. Default: main')
     .argument('[useCredentials]', 'When using git URL uses credentials for cloning. Default: false')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
     .action(async (source, branch, useCredentials, options) => {
     let resolvedSource = source;
     let resolvedBranch = branch;
@@ -525,20 +545,68 @@ importCmd
     .command('csv')
     .description('Imports cards from a csv file')
     .argument('<csvFile>', 'File to import from')
-    .argument('[cardKey]', 'Card key of the parent. If defined, cards are created as children of this card')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
+    .argument('[cardKey]', 'Parent card key. If defined, cards are created as children of this card')
     .action(async (csvFile, cardKey, options) => {
     const result = await commandHandler.command(Cmd.import, ['csv', csvFile, cardKey], Object.assign({}, options, program.opts()));
     handleResponse(result);
 });
-// 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, options) => {
+    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.')
     .argument('[source]', 'Source Card key that needs to be moved')
-    .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, destination, options) => {
+    .argument('[destination]', 'Destination Card key where "source" is moved to. If moving to root, use "root"');
+program.addCommand(moveCmd);
+moveCmd.action(async (source, destination, options) => {
     const result = await commandHandler.command(Cmd.move, [source, destination], Object.assign({}, options, program.opts()));
     handleResponse(result);
 });
@@ -549,16 +617,13 @@ program
     .action(async (dir) => {
     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')
     .description('Set the rank of a card. Ranks define the order in which cards are shown.')
     .argument('<cardKey>', 'Card key of the card to be moved')
     .argument('<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, afterCardKey, options) => {
     const result = await commandHandler.command(Cmd.rank, ['card', cardKey, afterCardKey], Object.assign({}, options, program.opts()));
     handleResponse(result);
@@ -566,22 +631,20 @@ rank
 rank
     .command('rebalance')
     .description('Rebalance the rank of all cards in the project. Can be also used, if ranks do not exist')
-    .argument('[parentCardKey]', 'if null, rebalance the whole project, otherwise rebalance only the direct children of the card key')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
+    .argument('[parentCardKey]', 'if null, rebalance the whole project, otherwise rebalance only the direct children')
     .action(async (cardKey, options) => {
     const result = await commandHandler.command(Cmd.rank, ['rebalance', cardKey], Object.assign({}, options, program.opts()));
     handleResponse(result);
 });
 // 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>)`, Parser.parseRemoveTypes)
     .argument('[parameter1]', 'Depends on context; see below for specific remove operation')
     .argument('[parameter2]', 'Depends on context; see below for specific remove operation')
     .argument('[parameter3]', 'Depends on context; see below for specific remove operation')
     .addHelpText('after', additionalHelpForRemove)
-    .option('-p, --project-path [path]', `${pathGuideline}`)
     .action(async (type, parameter1, parameter2, parameter3, options) => {
     if (type) {
         if (!parameter1) {
@@ -620,36 +683,33 @@ 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, options) => {
+    .argument('<to>', 'New project prefix');
+program.addCommand(renameCmd);
+renameCmd.action(async (to, options) => {
     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>', 'Path to parameters file. This file defines which report to run and what parameters to use.')
     .argument('[output]', 'Optional output file; if omitted output will be directed to stdout')
-    .addOption(contextOption)
-    .option('-p, --project-path [path]', `${pathGuideline}`)
-    .action(async (parameters, output, options) => {
+    .addOption(contextOption);
+program.addCommand(reportCmd);
+reportCmd.action(async (parameters, output, options) => {
     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(', ')}`, Parser.parseShowTypes)
     .argument('[typeDetail]', 'additional information about the requested type; for example a card key')
     .option('-d --details', 'Certain types (such as cards) can have additional details')
     .option('-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.')
     .action(async (type, typeDetail, options) => {
     if (type !== '') {
@@ -666,48 +726,43 @@ 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, transition, options) => {
+    .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.');
+program.addCommand(transitionCmd);
+transitionCmd.action(async (cardKey, transition, options) => {
     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>', 'Type of change, either "add", "change", "rank" or "remove" ')
     .argument('<key>', 'Detail to be changed')
     .argument('<value>', 'Value for a detail')
     .argument('[newValue]', 'When using "change" define new value for detail.\nWhen using "remove" provide optional replacement value for removed value')
-    .option('-m, --mapping-file [path]', 'Path to JSON file containing workflow state mapping (only used when changing workflow)')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
+    .option('-m, --mapping-file <path>', 'Path to JSON file containing workflow state mapping (only used when changing workflow)')
     .addHelpText('after', additionalHelpForUpdate)
     .action(async (resourceName, operation, key, value, newValue, options) => {
     const result = await commandHandler.command(Cmd.update, [resourceName, operation, key, value, newValue], Object.assign({}, options, program.opts()));
     handleResponse(result);
 });
 // 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) => {
+    .argument('[moduleName]', 'Module name');
+program.addCommand(updateModulesCmd);
+updateModulesCmd.action(async (moduleName, options) => {
     const result = await commandHandler.command(Cmd.updateModules, [moduleName], Object.assign({}, options, program.opts()), credentials());
     handleResponse(result);
 });
 // Validate command
-program
-    .command('validate')
-    .description('Validate project structure')
-    .option('-p, --project-path [path]', `${pathGuideline}`)
-    .action(async (options) => {
+const validateCmd = new CommandWithPath('validate').description('Validate project structure');
+program.addCommand(validateCmd);
+validateCmd.action(async (options) => {
     const result = await commandHandler.command(Cmd.validate, [], Object.assign({}, options, program.opts()));
     handleResponse(result);
 });
@@ -716,12 +771,11 @@ program
 // 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) => {
+    .option('-w, --watch-resource-changes', 'Project watches changes in .cards folder resources');
+program.addCommand(appCmd);
+appCmd.action(async (options) => {
     // validate project
     const result = await commandHandler.command(Cmd.validate, [], Object.assign({}, options, program.opts()));
     if (!result.message) {