@adinsure-ops/ops-cli 5.0.0-rc5 → 5.0.0

package/CHANGELOGS.md

@@ -3,7 +3,8 @@
 
 ## 5.0.0-rc5: 2023-09-08
 
-- Added --description flag to the log command
+- Added --description flag to the log command. It accepts the description of the changelog which will be used
+- Added --force flag to the log command. It creates folder structure if missing
 
 ## 5.0.0-rc4: 2023-09-05
 

package/README.md

@@ -47,6 +47,7 @@ You can run and debug commands directly from terminal by running `ops [command]`
 - [`ops npm:publish`](#ops-npmpublish)
 - [`ops npm:dependency-update`](#ops-npmdependency-update)
 - [`ops nuget:dependency-update`](#ops-nugetdependency-update)
+- [`ops prepare-content`](#ops-prepare-content-d-destination-s-source)
 - [`ops sql <type> <module> [flags]`](#ops-sql-type-module-flags)
 - [`ops translate`](#ops-translate)
 - [`ops version <type> [flags]`](#ops-version-type)
@@ -544,6 +545,217 @@ EXAMPLES
 \\
 > NPM packages node: For npm package to update properly _wsrun-version_ preset needs to be in _scripts_ portion of _package.json_. (example: `"wsrun-version": "yarn wsrun -p @adinsure-tools/* -p @adinsure/* -c"`)
 
+## `ops prepare-content -d <destination> -s [source]`
+
+creates a directory/file structure from `/source` to `/destination</source>` as defined in the `.opsprepare` file. Actual
+destination path for each file will be specified destination path with appended relative path from working directory where command is executed to specified source directory or current directory (if source is not specified). Be careful about using
+`..` notation in target and source paths as it may lead to unpredictable results due to relative path resolving.
+
+> Introduced in version 3.1.0.
+
+```txt
+USAGE
+  $ ops prepare-content -d <destination> -s [source]
+
+
+OPTIONS
+  -d, --destination=destination       path to target directory
+  -s, --source=source                 optional path to source directory containing .opsprepare file, (default: current directory)
+
+EXAMPLES
+$ ops prepare-content -d ./target_directory/
+  copies everything defined in .opsprepare
+  from current directory 
+  to ./target_directory
+
+$ ops prepare-content -d ./target_directory/ -s ./source_directory
+  copies everything defined in ./source_directory/.opsprepare 
+  from ./source_directory/
+  to ./target_directory/source_directory
+
+$ ops prepare-content -d C:\git\target_directory
+  copies everything defined in .opsprepare 
+  from current directory 
+  to C:\git\target_directory
+
+$ ops prepare-content -d C:\git\target_directory -s C:\git\subfolder\subfolder
+  when executed in c:\git it copies everything defined in C:\git\subfolder\subfolder\.opsprepare 
+  from C:\git\subfolder\subfolder
+  to C:\git\target_directory\subfolder\subfolder
+```
+
+### .opsprepare dotfile
+
+The prepare-content command uses `.opsprepare` dotfile as instruction set for content preparation.
+The syntax resembles that of `.gitignore` but differs in how it functions and doesn't support advanced
+pattern matching.
+
+Following operations/transformations are currently supported:
+
+- Copy: copies the file/directory from source path to destination path with same name
+- Transform: transform source file to destination file with same name
+- Removal: remove file/directory (based on source path) from destination path
+
+Before diving into the actual syntax and supported tokens let's look at an example
+of how using `ops prepare-content` creates a target directory structure with files
+based on the specified `.opsprepare` file residing in source directory.
+
+This is the example source directory structure:
+
+```ascii
+src_data
+├── .opsprepare
+├── README.tpl
+├── bin
+│   ├── ops.sh
+│   └── run
+│       └── ops
+├── dist
+│   └── server
+│       └── main.cs
+├── src
+│   ├── commands
+│   │   ├── prepare.ts
+│   │   └── version.ts
+│   ├── config.ts
+│   └── main.ts
+└── transform
+    └── render-tpl.js
+```
+
+Contents of `.opsprepare` file in the `src_data` directory:
+
+```txt
+# Comment
+src
+dist/server
+!src/commands
+!src/config.ts
+src/config.ts {cp:/src/configuration.ts}
+# Another comment
+!bin/run
+README.md {js:/transform/render-tpl.js}
+README.tpl {cp:/README.tpl.src}
+```
+
+Running `ops -s src_data -d dst_data` with `src_data/.opsprepare` containing above content
+results in:
+
+```ascii
+dst_data
+└── src_data
+    ├── README.md
+    ├── README.tpl.src
+    ├── dist
+    │   └── server
+    │       └── main.cs
+    └── src
+        ├── main.ts
+        └── src
+            └── configuration.ts
+```
+
+What actually happened:
+
+1. First note that all data was copied into `dst_data/src_data` because `.opsprepare` files relative
+   location to `ops` execution directiory is `src_data`.
+2. `src` directory was copied recursively to destination
+3. `dist/server` directory was copied recursively including its full path path relative to `src_data`
+4. `src/config.ts` file was transformed (copied) to `src/configuration.ts` in the destination
+5. `README.md` file was created at the destination as a result of JavaScript based transformation
+6. `README.tpl` file was transformed (copied) to `README.tpl.src` in the destination
+7. `src/commands` directory was removed from destination
+8. `src/config.ts` file was removed from destination
+9. `bin/run` directory was removed from destination
+
+Note that copying and explicit transformations are performed before any removal operations.
+
+#### Comments
+
+Any line prefixed by `#` is considered a comment and will not result in any file/directory operation.
+
+#### Copy operations
+
+Any file/directory not prefixed by `!` or `#` having explicit transformation defined in `{...}` after
+its name will be copied to the destination with it's full path relative to `ops` execution directory
+to the target directory.
+
+#### Transformation operations
+
+Transformation operations are always specified using curly braces following the source file name. Base
+syntax looks like this:
+
+```txt
+{<transformation type>:<transformation parameters>}
+```
+
+Two types of transformation operations are supported:
+
+- cp: copy transformation which supports renaming of the source file at the destination
+- js: JavasSript based transformation which results in the file containing string returned by the
+  transformation function contained in transformation module.
+
+**cp - copy transformation syntax**
+
+```txt
+{cp:<destination path>}
+
+Examples:
+{cp:/dst/newfilename}
+{cp:dst/newfilenames}
+```
+
+Copy transformation is supported for both files and directories. Source file or directory will be
+copied to the destination path with its new name. The destination will always be relative to the
+destination path of entire `prepare-content` operation therefore paths in the transformation block
+can start with or without the `/` character but using makes the syntax more readable.
+
+**js - JavaScript transformation syntax**
+
+```txt
+{js:<transformation_module_path>}
+
+Example:
+{js:/transformations/templateRenderer.js}
+```
+
+JavaScript transformation is supported only for files, not directories.
+
+Transformation module path should be relative to `.opsprepare` file but can start with `/` character
+for better readability. It can export multiple functions though only one can be used in single
+transformation specification.
+
+Transformation function that is defined in the transformation module will be called with a single
+parameter - absolute path of the source file. 
+
+Transformation function MUST return a string. This string will become the content of the file on
+destination.
+
+Destination file will be created with the same name as source file and content returned by the
+transformation function. The existence of actual source file will not be validated by the
+`prepare-content` operation (warning is shown if it doesn't exist), such validation is responsibility
+of the transformation function if required.
+
+Example transformation module `transform.js` with exported function called render:
+
+```js
+export default function render(path) {
+    /*
+    Some transformation happens in here and it's result which is
+    a string is assigned to result variable which is returned.
+    */
+  return result;
+}
+```
+
+> An important thing to note is that you can only export one default function in a module, so defining multiple functions in one file that call each other is possible,
+> however defining multiple default exports is not and therefore **there can only be one function that will be called** in a module file.
+
+#### Removal operations
+
+Any file/directory prefixed by `!` will be removed from the destination based on it's full path
+relative from `ops` execution directory to source file/directory path.
+
 ## `ops sql <type> <module> [flags]`
 
 creates a new database script

package/lib/commands/download/studio.d.ts

@@ -10,6 +10,7 @@ export default class DownloadStudio extends CommandBase<typeof DownloadStudio> {
         install: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         skip: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         keep: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     private readonly url;
     /**

package/lib/commands/download/studio.js

@@ -48,6 +48,9 @@ class DownloadStudio extends CommandBase {
         return __awaiter(this, void 0, void 0, function* () {
             const { flags } = yield this.parse(DownloadStudio);
             const basePath = flags.output;
+            if (flags.force && !(yield fs.pathExists(basePath))) {
+                yield fs.mkdirp(basePath);
+            }
             const filename = `adinsure-studio-${flags.version}.vsix`;
             const studioVersion = `adacta-fintech.adinsure-studio@${flags.version}`;
             const filePath = path.resolve(basePath, filename);
@@ -107,6 +110,7 @@ DownloadStudio.description = 'download AdInsure Studio vsix from azure storage';
 DownloadStudio.usage = 'download:studio <flags>';
 DownloadStudio.examples = [
     `$ ops download:studio -v 15.0.0 -o ~/Downloads`,
+    `$ ops download:studio -v 15.0.0 -o ~/Downloads -f`,
     `$ ops download:studio -v 15.0.0 -i`,
     `$ ops download:studio -v 15.0.0 -i -s`,
     `$ ops download:studio -v 15.0.0 -i -k`,
@@ -137,5 +141,11 @@ DownloadStudio.flags = {
         description: 'only with install. If passed, it will not remove the vsix file.',
         dependsOn: ['install'],
     }),
+    force: Flags.boolean({
+        char: 'f',
+        description: 'Create output directory if it does not exist.',
+        default: false,
+        dependsOn: ['output'],
+    }),
 };
 export default DownloadStudio;

package/lib/commands/log/add.d.ts

@@ -11,6 +11,7 @@ export default class Changelog extends CommandBase<typeof Changelog> {
         type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         component: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/lib/commands/log/add.js

@@ -12,6 +12,9 @@ class Changelog extends CommandBase {
             // Validation of input parameters
             const changelogFolderBase = yield this.getChangelogsRoot();
             const possibleComponents = [];
+            if (flags.force && !(yield fs.pathExists(changelogFolderBase))) {
+                yield fs.mkdirp(changelogFolderBase);
+            }
             for (const file of fs.readdirSync(changelogFolderBase)) {
                 if (fs.statSync(path.resolve(changelogFolderBase, file)).isDirectory()) {
                     possibleComponents.push(file);
@@ -88,6 +91,7 @@ Changelog.usage = 'log <issue> -t [type] -c [options]';
 Changelog.examples = [
     `$ ops log LJADIRD-1234 -t feature`,
     `$ ops log LJADIRD-5678 -t fixed`,
+    `$ ops log LJADIRD-5678 -t fixed -d "Fixed my bug"`,
     `$ ops log LJADIRD-8765 -t breaking -c Platform`,
     `$ ops log LJADIRD-4321 -t improve -c Configuration`,
 ];
@@ -113,5 +117,10 @@ Changelog.flags = {
         description: 'Description of a changelog',
         default: '',
     }),
+    force: Flags.boolean({
+        char: 'f',
+        description: 'Create logs directory if it does not exist',
+        default: false,
+    }),
 };
 export default Changelog;

package/lib/commands/prepare-content.d.ts

@@ -0,0 +1,28 @@
+import CommandBase from '../command.base.js';
+interface Transformation {
+    name: string;
+    srcPath: string;
+    transform(): void;
+}
+interface DotfileLine {
+    prefix: string;
+    source: string;
+    transformData: string;
+}
+export default class PrepareContent extends CommandBase<typeof PrepareContent> {
+    static readonly dotfile = ".opsprepare";
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        destination: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        source: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    parseDotfileLine(line: string, sourceDirectory: string): Promise<DotfileLine>;
+    readDotfile(sourceDirectory: string): Promise<DotfileLine[]>;
+    getTransformation(lineData: DotfileLine, baseSourcedir: string, baseDestinationDir: string): Promise<Transformation>;
+    prepareTransformations(linesData: DotfileLine[], baseSourceDir: string, baseDestinationDir: string): Promise<Transformation[]>;
+    runTransformations(transformations: Transformation[]): Promise<void>;
+    run(): Promise<void>;
+}
+export {};

package/lib/commands/prepare-content.js

@@ -0,0 +1,411 @@
+import { __awaiter } from "tslib";
+import { Flags, ux } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import CommandBase from '../command.base.js';
+class CopyTransformation {
+    constructor(srcPath, dstPath) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+        this.dstPath = dstPath;
+    }
+    transform() {
+        try {
+            fs.accessSync(this.srcPath, fs.constants.R_OK);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error_) {
+            const error = error_.code === 'ENOENT' ? new Error(`${this.name}: source file does not exist <${this.srcPath}>`) : new Error(`${this.name}: ${error_} <${this.srcPath}>`);
+            throw error;
+        }
+        ux.log(`Copying from ${this.srcPath} to ${this.dstPath}`);
+        try {
+            fs.copySync(this.srcPath, this.dstPath, { overwrite: true });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            throw new Error(`${this.name}: ${error} <${this.srcPath}>`);
+        }
+    }
+}
+class JavascriptTransformation {
+    constructor(srcPath, dstPath, javascriptFile) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+        this.dstPath = dstPath;
+        this.jsFile = javascriptFile;
+    }
+    importTransformationFunction() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { default: transformationFunction } = yield import(this.jsFile);
+                return transformationFunction;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if (error.code === 'ERR_MODULE_NOT_FOUND') {
+                    throw new Error(`${this.name}: module file ${this.jsFile} not found <${this.srcPath}>`);
+                }
+                else if (error instanceof SyntaxError) {
+                    throw new SyntaxError(`${this.name}: ${error.message} in '${this.jsFile}' <${this.srcPath}>`);
+                }
+                throw new Error(`${this.name}: ${error} <${this.srcPath}>`);
+            }
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    executeTransformationFunction(transformationFunction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield transformationFunction(this.srcPath);
+                if (typeof result !== 'string') {
+                    throw new TypeError(`${this.name}: transformation functions must return string, the script returned ${typeof (result)} <${this.srcPath}>`);
+                }
+                return result;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if (error instanceof TypeError && error.message.search(`/.*must return.*/`) !== -1) {
+                    console.log(error.message.search(`/.*must return.*/`));
+                    throw new Error(`${this.name}: invalid function in ${this.jsFile} <${this.srcPath}>`);
+                }
+                /*
+                Rethrow anything errors that were thrown in the above try block
+                */
+                if (error.message && error.message.search(`${this.name}`.length > 0)) {
+                    throw error;
+                }
+                throw new Error(`${this.name}: ${error} <${this.srcPath}>`);
+            }
+        });
+    }
+    transform() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check if source exists, if not, issue a warning
+            try {
+                fs.accessSync(this.srcPath);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    const errMsg = `${this.name}: source does not exist, relying on transformation to find proper source file <${this.srcPath}>`;
+                    ux.log(`${chalk.yellow(errMsg)}`);
+                }
+                else {
+                    throw new Error(`${this.name}: ${error} <${this.srcPath}>`);
+                }
+            }
+            const msg = `Transforming from ${this.srcPath} to ${this.dstPath} using ${this.jsFile}`;
+            ux.log(`${chalk.yellow(msg)}`);
+            // eslint-disable-next-line no-useless-catch
+            try {
+                // Import transformation function
+                const transFunction = yield this.importTransformationFunction();
+                // Execute transformation function
+                const transResult = yield this.executeTransformationFunction(transFunction);
+                fs.outputFileSync(this.dstPath, transResult, { encoding: 'utf8', mode: 0o644, flag: 'w' });
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+}
+class RemovalTransformation {
+    constructor(srcPath) {
+        this.name = this.constructor.name;
+        this.srcPath = srcPath;
+    }
+    transform() {
+        try {
+            fs.accessSync(this.srcPath, fs.constants.W_OK);
+            ux.log(`Removing ${this.srcPath}.`);
+            fs.removeSync(this.srcPath);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                const errMsg = `${this.name}: target does not exist, skipping removal <${this.srcPath}>`;
+                ux.log(`${chalk.yellow(errMsg)}`);
+            }
+            else {
+                throw new Error(`${this.name}: ${error} <${this.srcPath}>`);
+            }
+        }
+    }
+}
+class PrepareContent extends CommandBase {
+    parseDotfileLine(line, sourceDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const m = line.match('^([!#])?(.+?)({.*?})?$');
+            const dotfileLine = {
+                prefix: m[1],
+                source: path.join(sourceDirectory, path.normalize(m[2].trim())),
+                transformData: m[3],
+            };
+            /*
+            Sanity check on source file name. Should not contain "{", ":", or "}" characters
+            */
+            const vm = dotfileLine.source.match('[{:}]+');
+            if (vm !== null) {
+                throw new SyntaxError(`<${PrepareContent.dotfile}> source file name '${dotfileLine.source}' contains invalid character '${vm[0]}'`);
+            }
+            return dotfileLine;
+        });
+    }
+    readDotfile(sourceDirectory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let fileContent;
+            try {
+                fileContent = fs.readFileSync(path.join(sourceDirectory, PrepareContent.dotfile), 'utf8');
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                if (error.code === 'ENOENT') {
+                    const errMsg = `.opsprepare file not found in ${path.resolve(sourceDirectory)}`;
+                    throw new Error(errMsg);
+                }
+                throw new Error(error.message);
+            }
+            const lines = fileContent.split(/\r?\n/).filter(line => line.length > 0);
+            const lineParse = lines.map(line => {
+                return this.parseDotfileLine(line.trim(), sourceDirectory);
+            });
+            const parsedLines = Promise.all(lineParse).then(lines => lines.filter(line => line.prefix !== '#'));
+            return parsedLines;
+        });
+    }
+    getTransformation(lineData, baseSourcedir, baseDestinationDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetPath = path.join(baseDestinationDir, lineData.source);
+            /*
+            Anything prefixed with ! is a removal
+            */
+            if (lineData.prefix === '!') {
+                return new RemovalTransformation(targetPath);
+            }
+            /*
+            In case transformation data is present, prepare transformations based on requested plugin.
+            */
+            if (lineData.transformData) {
+                const transformType = lineData.transformData.match('^{(.+?):.*}$')[1];
+                switch (transformType) {
+                    case 'cp': {
+                        const mPath = lineData.transformData.match('^{cp:([^:]+)}$');
+                        if (!mPath) {
+                            throw new SyntaxError(`<${PrepareContent.dotfile}> syntax '${lineData.transformData}' is invalid for 'cp' transformation type`);
+                        }
+                        const tPath = path.join(baseDestinationDir, path.dirname(lineData.source), mPath[1]);
+                        return new CopyTransformation(lineData.source, tPath);
+                    }
+                    case 'js': {
+                        /* TODO: Some sanity checking will be required after regex matching
+                        to make sure everything was matched and is defined
+                        */
+                        // Parse transformation data
+                        const mData = lineData.transformData.match('^{js:(.+?).js}$');
+                        if (!mData) {
+                            throw new SyntaxError(`<${PrepareContent.dotfile}> syntax '${lineData.transformData}' is invalid for 'js' transformation type`);
+                        }
+                        const jsFile = 'file://' + path.resolve(path.join(baseSourcedir, mData[1])) + '.js';
+                        // File path absolute
+                        const filePath = path.resolve(lineData.source);
+                        return new JavascriptTransformation(filePath, targetPath, jsFile);
+                    }
+                    default: {
+                        const p = lineData.prefix || '';
+                        const s = lineData.source;
+                        const t = lineData.transformData || '';
+                        this.error(`No valid transformation can be extrapolated from ${p}${s}${t}`);
+                    }
+                }
+            }
+            /*
+            Return default transformation
+            */
+            return new CopyTransformation(lineData.source, targetPath);
+        });
+    }
+    prepareTransformations(linesData, baseSourceDir, baseDestinationDir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transformations = linesData.map(line => {
+                return this.getTransformation(line, baseSourceDir, baseDestinationDir);
+            });
+            return Promise.all(transformations);
+        });
+    }
+    /*
+    This function divides transformations into execution groups based on their class
+    and runs transformations for each group
+    */
+    runTransformations(transformations) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const copyTransformList = [];
+            const modlueTransformList = [];
+            const excludeList = [];
+            // Sort transformation into two lists
+            for (const t of transformations) {
+                if (t instanceof CopyTransformation) {
+                    copyTransformList.push(t);
+                }
+                else if (t instanceof RemovalTransformation) {
+                    excludeList.push(t);
+                }
+                else {
+                    modlueTransformList.push(t);
+                }
+            }
+            const t = (transformation) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    transformation.transform();
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (error) {
+                    throw Promise.reject(error.message).catch(error_ => {
+                        this.log(`${chalk.redBright('ERROR: ' + error_)}`);
+                    });
+                }
+            });
+            /* eslint-disable unicorn/no-array-callback-reference */
+            const doCopyTransform = copyTransformList.map(t);
+            const doModuleTransform = modlueTransformList.map(t);
+            const doExclude = excludeList.map(t);
+            /* eslint-enable unicorn/no-array-callback-reference */
+            /* Copy first, then transform and finally remove files. This should
+               ensure that transformations can overwrite previous copies. Removals
+               can still erase transformations though. If needed, we can remove
+               before transforming.
+            */
+            yield Promise.all(doCopyTransform);
+            yield Promise.all(doModuleTransform);
+            yield Promise.all(doExclude);
+        });
+    }
+    /*
+    Validates file system on source repository by checking if files or directories exist
+    */
+    /*
+    async validate(arr: string[][], source: string): Promise<boolean> {
+        //this.log(`${chalk.blue('Validating if files and directories exist.')}`);
+        cli.action.start(`${chalk.blue('Validating if files and directories exist')}`, '', {stdout: true});
+        for (let a of arr[0]) {
+            let element_path = path.join(source, a);
+            if(!(fs.existsSync(path.join(element_path)))) {
+                this.log(`${chalk.red('File or directory: ' + path.join(element_path) + ' could not be found')}`);
+                return false;
+            }
+        }
+        for (let a of arr[1]) {
+            let element_path = path.join(source, a);
+            if(!(fs.existsSync(element_path))) {
+                this.log(`${chalk.red('File or directory: ' + element_path + ' could not be found')}`);
+                return false;
+            }
+        }
+
+        //this.log(`${chalk.green('Validation done.')}`);
+        cli.action.stop(`${chalk.green('done')}`);
+        return true;
+    }
+    */
+    /*
+    This function copies elements and removes excluded ones.
+    */
+    /*
+    async copyWorkspace(arr: string[][], dest: string, source: string): Promise<any> {
+        if (await this.validate(arr, source)) {
+            cli.action.start(`${chalk.blue('Preparing content')}`, '', {stdout: true});
+            arr[0].forEach(a => {
+                this.log('Copying: ', path.join(source, a));
+                fs.copySync(path.join(source, a), path.join(dest, a), {overwrite: true});
+            });
+            this.log(`${chalk.green('Copying done.')}`);
+            this.log(`${chalk.blue('Removing excluded elements.')}`);
+            arr[1].forEach(a => {
+                let curPath = path.join(dest, a);
+                if (fs.pathExistsSync(curPath)) {
+                    if (fs.lstatSync(curPath).isFile()) {
+                        try {
+                            fs.removeSync(curPath);
+                            this.log('Removing file: ', curPath);
+                        } catch (err: any) {
+                            cli.action.stop(`${chalk.red('failed')}`);
+                            this.error(error.message);
+                        }
+                    } else if (fs.lstatSync(curPath).isDirectory()) {
+                        try {
+                            fs.removeSync(curPath);
+                            this.log('Removing dir: ', curPath);
+                        } catch (err: any) {
+                            cli.action.stop(`${chalk.red('failed')}`);
+                            this.error(error.message);
+                        }
+                    } else {
+                        cli.action.stop(`${chalk.red('error')}`);
+                        this.error('Type not file or directory');
+                    }
+                }
+            });
+            this.log(`${chalk.green('Removing done.')}`);
+            cli.action.stop(`${chalk.green('done')}`);
+        } else {
+            cli.action.stop(`${chalk.red('error')}`);
+            this.error('Content validation failed.');
+        }
+    }
+    */
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { flags } = yield this.parse(PrepareContent);
+            // read the flags and set paths relative to execution directory
+            let source = path.relative(process.cwd(), flags.source);
+            source = source || '.';
+            console.log(source);
+            const dest = flags.destination;
+            try {
+                const dotfileLines = yield this.readDotfile(source);
+                this.log(`${chalk.blue('Content transformation started.')}`);
+                const transformations = yield this.prepareTransformations(dotfileLines, source, dest);
+                yield this.runTransformations(transformations);
+                this.log(`${chalk.green('Content prepared at: ', dest)}`);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (error) {
+                this.log(`${chalk.red(error)}`);
+                /*
+                In test mode, exit with status 0
+                */
+                if (process.env.OPS_TEST_MODE === 'true') {
+                    this.exit(0);
+                }
+                console.log(error.message);
+                this.exit(1);
+            }
+        });
+    }
+}
+PrepareContent.dotfile = '.opsprepare';
+PrepareContent.description = `copies files as described in ${PrepareContent.dotfile} which is at root of source directory`;
+PrepareContent.usage = 'prepare-content -d <destination> [-s <source>]';
+PrepareContent.examples = [
+    `$ ops prepare-content -d .\\my_workspace`,
+    `$ ops prepare-content -d .\\my_workspace -s .\\my_repository`,
+    `$ ops prepare-content -d C:\\git\\my_workspace`,
+    `$ ops prepare-content -d C:\\git\\my_workspace -s C:\\git\\my_repository\\my_repository`,
+];
+PrepareContent.flags = {
+    destination: Flags.string({
+        char: 'd',
+        description: 'where to copy the workspace files',
+        required: true,
+    }),
+    source: Flags.string({
+        char: 's',
+        description: '[optional] source directory, default: current dir',
+        required: false,
+        default: '.',
+    }),
+};
+export default PrepareContent;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.0.0-rc5",
+  "version": "5.0.0",
   "commands": {
     "doctor": {
       "id": "doctor",
@@ -88,6 +88,43 @@
       "args": {},
       "responsePageContent": "\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>ops-cli authenticate</title>\n        <link rel='icon' href='data:;base64,iVBORw0KGgo='>\n    </head>\n    <body>\n        <p><strong>Your login was successful!</strong></p>\n        <p>This page will automatically close after 10 seconds OR you can close it yourself immediately.</p>\n        <script type='text/javascript'>\n            setTimeout('self.close()', 10000);\n        </script>\n    </body>\n</html>"
     },
+    "prepare-content": {
+      "id": "prepare-content",
+      "description": "copies files as described in .opsprepare which is at root of source directory",
+      "strict": true,
+      "usage": "prepare-content -d <destination> [-s <source>]",
+      "pluginName": "@adinsure-ops/ops-cli",
+      "pluginAlias": "@adinsure-ops/ops-cli",
+      "pluginType": "core",
+      "aliases": [],
+      "examples": [
+        "$ ops prepare-content -d .\\my_workspace",
+        "$ ops prepare-content -d .\\my_workspace -s .\\my_repository",
+        "$ ops prepare-content -d C:\\git\\my_workspace",
+        "$ ops prepare-content -d C:\\git\\my_workspace -s C:\\git\\my_repository\\my_repository"
+      ],
+      "flags": {
+        "destination": {
+          "name": "destination",
+          "type": "option",
+          "char": "d",
+          "description": "where to copy the workspace files",
+          "required": true,
+          "multiple": false
+        },
+        "source": {
+          "name": "source",
+          "type": "option",
+          "char": "s",
+          "description": "[optional] source directory, default: current dir",
+          "required": false,
+          "multiple": false,
+          "default": "."
+        }
+      },
+      "args": {},
+      "dotfile": ".opsprepare"
+    },
     "sql": {
       "id": "sql",
       "description": "creates a new database script",
@@ -633,6 +670,7 @@
       "aliases": [],
       "examples": [
         "$ ops download:studio -v 15.0.0 -o ~/Downloads",
+        "$ ops download:studio -v 15.0.0 -o ~/Downloads -f",
         "$ ops download:studio -v 15.0.0 -i",
         "$ ops download:studio -v 15.0.0 -i -s",
         "$ ops download:studio -v 15.0.0 -i -k"
@@ -680,6 +718,16 @@
           "dependsOn": [
             "install"
           ]
+        },
+        "force": {
+          "name": "force",
+          "type": "boolean",
+          "char": "f",
+          "description": "Create output directory if it does not exist.",
+          "allowNo": false,
+          "dependsOn": [
+            "output"
+          ]
         }
       },
       "args": {}
@@ -928,6 +976,7 @@
       "examples": [
         "$ ops log LJADIRD-1234 -t feature",
         "$ ops log LJADIRD-5678 -t fixed",
+        "$ ops log LJADIRD-5678 -t fixed -d \"Fixed my bug\"",
         "$ ops log LJADIRD-8765 -t breaking -c Platform",
         "$ ops log LJADIRD-4321 -t improve -c Configuration"
       ],
@@ -960,6 +1009,13 @@
           "description": "Description of a changelog",
           "multiple": false,
           "default": ""
+        },
+        "force": {
+          "name": "force",
+          "type": "boolean",
+          "char": "f",
+          "description": "Create logs directory if it does not exist",
+          "allowNo": false
         }
       },
       "args": {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@adinsure-ops/ops-cli",
     "description": "Operations CLI for working with AdInsure",
-    "version": "5.0.0-rc5",
+    "version": "5.0.0",
     "author": "Adacta Digital Service Department",
     "bin": {
         "ops": "./bin/run.js"
@@ -64,7 +64,7 @@
         "mock-spawn": "^0.2.6",
         "nock": "^13.1.3",
         "nyc": "^15.1.0",
-        "oclif": "^3.11.3",
+        "oclif": "^3.15.0",
         "sinon": "^15.1.0",
         "timekeeper": "^2.2.0",
         "ts-mockito": "^2.6.1",