How to use the semver.inc function in semver

//
// Helper script to bump the version number
//
// TODO: a Node.js dependency in a Python package is not ideal.
//
var fs = require('fs');
var _ = require('underscore');

var version = (fs.readFileSync("VERSION", "utf8") || "1.0.0").replace(/\s+$/, "");
var newVersion = require("semver").inc(version, "patch");
fs.writeFileSync("VERSION", newVersion);
fs.writeFileSync("lightstep/version.py", "LIGHTSTEP_PYTHON_TRACER_VERSION=\"" + newVersion + "\"\n");

// Naive micro-sed on setup.py
var setuppy = _.map(fs.readFileSync("setup.py", "utf8").split("\n"), function(line) {
    return line.replace("'" + version + "'", "'" + newVersion + "'");
}).join("\n");
fs.writeFileSync("setup.py", setuppy);

console.log(version + " -> " + newVersion);

gulp.task('bump-version', function(cb) {
    function doVersionBump() {
      gulp.src([`${CWD}/package.json`, `${CWD}/package-lock.json`])
        .pipe(bump({version: releaseVersion}))
        .pipe(gulp.dest('./'))
        .pipe(git.commit(`releng - Release ${releaseVersion}`));
      
      cb();
    }
    
    const currentVersion = modulePackageJson.version;
    
    // Potential versions
    const patchVersion = semver.inc(currentVersion, 'patch');
    const minorVersion = semver.inc(currentVersion, 'minor');
    const majorVersion = semver.inc(currentVersion, 'major');
    const preVersion = semver.inc(currentVersion, 'prerelease', 'beta');
    const preMajorVersion = semver.inc(currentVersion, 'premajor', 'beta');
    const preMinorVersion = semver.inc(currentVersion, 'preminor', 'beta');
    const prePatchVersion = semver.inc(currentVersion, 'prepatch', 'beta');
    
    // Command line bump shortcuts
    if (gutil.env.pre) {
      releaseVersion = preVersion;
    }
    else if (gutil.env.patch) {
      releaseVersion = patchVersion;
    }
    else if (gutil.env.minor) {
      releaseVersion = minorVersion;
    }

let current = this.get('version');
        let newVersion;
        if (version === 'canary') {
            tag = 'alpha';
            newVersion = semver.inc(current, 'prerelease', 'alpha').replace(/\.\d+$/, `.${hash.trim()}`);
        } else if (version === 'alpha') {
            tag = 'alpha';
            newVersion = semver.inc(current, 'prerelease', 'alpha');
        } else if (version === 'beta') {
            tag = 'beta';
            newVersion = semver.inc(current, 'prerelease', 'beta');
        } else if (version === 'rc') {
            tag = 'rc';
            newVersion = semver.inc(current, 'prerelease', 'rc');
        } else if (version === 'patch') {
            newVersion = semver.inc(current, 'patch');
        } else if (version === 'minor') {
            newVersion = semver.inc(current, 'minor');
        } else if (version === 'major') {
            newVersion = semver.inc(current, 'major');
        } else if (version) {
            newVersion = version;
        } else if (!process.env.CI) {
            // prompt
            const answers = await inquirer.prompt([
                {
                    name: 'version',
                    message: 'select the version to bump',
                    type: 'list',
                    choices: [
                        `patch (${semver.inc(current, 'patch')})`,
                        `minor (${semver.inc(current, 'minor')})`,

.then( version => {
			if ( version === 'skip' ) {
				return Promise.resolve();
			}

			// If the user provided "internal" as a new version, we treat it as a "patch" bump.
			if ( version === 'internal' ) {
				isInternalRelease = true;
				version = semver.inc( packageJson.version, 'patch' );
			}

			const changelogOptions = {
				version,
				tagName,
				isInternalRelease,
				indentLevel,
				newTagName: 'v' + version,
				transformCommit: transformCommitForSubRepositoryFactory( {
					treatMajorAsMinorBreakingChange: options.disableMajorBump,
					useExplicitBreakingChangeGroups: !!options.useExplicitBreakingChangeGroups
				} ),
				skipLinks: !!options.skipLinks
			};

			return generateChangelogFromCommits( changelogOptions )

,jshint = require('jshint')
	,_ = require('underscore')
	,cli = require('commander')

	,ENC = 'utf8'

	// DOGFOOD!
	//,vash = require('../build/vash')
	//,vashOpts = {
	//	 favorText: true
	//	,modelName: 'it'
	//	,client: false
	//}

	,pkg = JSON.parse( fs.readFileSync(__dirname + '/../package.json', ENC) )
	,buildNum = semver.inc( pkg.version, 'build' )

	,exp = fs.readFileSync(__dirname + '/../src/vash.exports.js', ENC)

	// this will be transformed into an object containing templates keyed by filename
	,tpls = [ 
		'../support/license.header.js' 
	]

	,fileGroups = {

		lint: [
			 '../src/vash.exports.js'
			,'../src/vruntime.js'
			,'../src/vhelpers.js'
			,'../src/vlexer.js'
			,'../src/vast.js'

it('should correctly work when outdated', () => {
        process.env[ENV_VARS.SDK_LATEST_VERSION] = semver.inc(currentVersion, 'minor');
        console.log(process.env[ENV_VARS.SDK_LATEST_VERSION]);
        logMock.expects('warning').once();
        utils.printOutdatedSdkWarning();
        delete process.env[ENV_VARS.SDK_LATEST_VERSION];
    });

.then(contents => {
      let json = JSON.parse(contents);
      let version;
      const oldVersion = json.version;

      if (type === undefined) {
        if (!preid) {
          throw new Error('Must specify version bump type');
        }

        version = oldVersion;
      } else {
        if (['major', 'minor', 'patch'].indexOf(type) === -1) {
          version = type;
        } else {
          version = semver.inc(json.version, type);
        }
      }

      if (preid) {
        version = semver.inc(version, 'pre', preid);
      }

      console.log('Version changed from '.cyan + oldVersion.green + ' to '.cyan + version.green);
      json.version = version;

      return fsp.writeFile(packagePath, JSON.stringify(json, null, 2) + '\n')
        .then(() => safeExec(`git add ${packagePath}`))
        .then(() => json.version);
    });
}

function getVersion() {
  var input = readline.question("New version (Leave blank for new patch): ");

  var ver = semver.valid(input);
  if (!ver) {
    ver = semver.inc(CURRENT_VERSION, input || "patch");
  }

  if (ver) {
    return ver;
  } else {
    console.log("Version provided is not valid semver.");
    return getVersion();
  }
}

export async function promptPublishableVersion(extJson) {
  const dev = await ensureUserIsLoggedIn();
  while (true) {
    const { name, version } = extJson;
    const canonical = getExtensionCanonicalName(dev.name, name, version);
    const canExtensionBePublished = await spinify(canPublish(canonical), `Checking if version ${version} can be published`);
    if (canExtensionBePublished) {
      return;
    }
    const { newVersion } = await prompt({
      name: 'newVersion',
      default: semver.inc(version, 'patch'),
      message: `Version ${version} is already published. Specify another version:`,
      validate: v => !!semver.valid(v),
    });
    extJson.version = newVersion;
  }
}

bumps.forEach(b => {
        versions[b] = semver.inc(current, b);
    });