ic-mops 0.23.0 → 0.25.0

package/declarations/main/main.did

@@ -1,5 +1,3 @@
-type Version = text;
-type Ver = text;
 type User__1 = 
  record {
    displayName: text;
@@ -35,20 +33,34 @@ type StorageStats =
    memorySize: nat;
  };
 type StorageId = principal;
+type SemverPart = 
+ variant {
+   major;
+   minor;
+   patch;
+ };
 type Script = 
  record {
    name: text;
    value: text;
  };
-type Result_6 = 
+type Result_7 = 
  variant {
    err: Err;
    ok: vec FileId;
  };
+type Result_6 = 
+ variant {
+   err: Err;
+   ok: vec record {
+             PackageName__1;
+             PackageVersion;
+           };
+ };
 type Result_5 = 
  variant {
    err: Err;
-   ok: Ver;
+   ok: PackageVersion;
  };
 type Result_4 = 
  variant {
@@ -78,6 +90,7 @@ type Result =
 type PublishingId = text;
 type PublishingErr = text;
 type PageCount = nat;
+type PackageVersion = text;
 type PackageSummary__1 = 
  record {
    config: PackageConfigV2__1;
@@ -181,25 +194,34 @@ type DependencyV2 =
    version: text;
  };
 service : {
+  backup: () -> ();
   claimAirdrop: (principal) -> (text);
   finishPublish: (PublishingId) -> (Result);
   getAirdropAmount: () -> (nat) query;
   getAirdropAmountAll: () -> (nat) query;
   getApiVersion: () -> (Text) query;
-  getDefaultPackages: (text) -> (vec record {
-                                       PackageName__1;
-                                       Version;
-                                     }) query;
+  getBackupCanisterId: () -> (principal) query;
+  getDefaultPackages: (text) ->
+   (vec record {
+          PackageName__1;
+          PackageVersion;
+        }) query;
   getDownloadTrendByPackageId: (PackageId) ->
    (vec DownloadsSnapshot__1) query;
   getDownloadTrendByPackageName: (PackageName__1) ->
    (vec DownloadsSnapshot__1) query;
-  getFileIds: (PackageName__1, Ver) -> (Result_6) query;
+  getFileIds: (PackageName__1, PackageVersion) -> (Result_7) query;
+  getHighestSemverBatch:
+   (vec record {
+          PackageName__1;
+          PackageVersion;
+          SemverPart;
+        }) -> (Result_6) query;
   getHighestVersion: (PackageName__1) -> (Result_5) query;
   getMostDownloadedPackages: () -> (vec PackageSummary) query;
   getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
   getNewPackages: () -> (vec PackageSummary) query;
-  getPackageDetails: (PackageName__1, Ver) -> (Result_4) query;
+  getPackageDetails: (PackageName__1, PackageVersion) -> (Result_4) query;
   getPackagesByCategory: () -> (vec record {
                                       text;
                                       vec PackageSummary;
@@ -212,7 +234,8 @@ service : {
   getTotalDownloads: () -> (nat) query;
   getTotalPackages: () -> (nat) query;
   getUser: (principal) -> (opt User__1) query;
-  notifyInstall: (PackageName__1, Ver) -> () oneway;
+  notifyInstall: (PackageName__1, PackageVersion) -> () oneway;
+  restore: (nat, nat) -> ();
   search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
   setUserProp: (text, text) -> (Result_3);
   startFileUpload: (PublishingId, Text, nat, blob) -> (Result_2);

package/declarations/main/main.did.d.ts

@@ -94,6 +94,7 @@ export interface PackageSummary__1 {
   'config' : PackageConfigV2__1,
   'publication' : PackagePublication,
 }
+export type PackageVersion = string;
 export type PageCount = bigint;
 export type PublishingErr = string;
 export type PublishingId = string;
@@ -107,11 +108,16 @@ export type Result_3 = { 'ok' : null } |
   { 'err' : string };
 export type Result_4 = { 'ok' : PackageDetails } |
   { 'err' : Err };
-export type Result_5 = { 'ok' : Ver } |
+export type Result_5 = { 'ok' : PackageVersion } |
   { 'err' : Err };
-export type Result_6 = { 'ok' : Array<FileId> } |
+export type Result_6 = { 'ok' : Array<[PackageName__1, PackageVersion]> } |
+  { 'err' : Err };
+export type Result_7 = { 'ok' : Array<FileId> } |
   { 'err' : Err };
 export interface Script { 'value' : string, 'name' : string }
+export type SemverPart = { 'major' : null } |
+  { 'minor' : null } |
+  { 'patch' : null };
 export type StorageId = Principal;
 export interface StorageStats {
   'fileCount' : bigint,
@@ -144,17 +150,17 @@ export interface User__1 {
   'githubVerified' : boolean,
   'github' : string,
 }
-export type Ver = string;
-export type Version = string;
 export interface _SERVICE {
+  'backup' : ActorMethod<[], undefined>,
   'claimAirdrop' : ActorMethod<[Principal], string>,
   'finishPublish' : ActorMethod<[PublishingId], Result>,
   'getAirdropAmount' : ActorMethod<[], bigint>,
   'getAirdropAmountAll' : ActorMethod<[], bigint>,
   'getApiVersion' : ActorMethod<[], Text>,
+  'getBackupCanisterId' : ActorMethod<[], Principal>,
   'getDefaultPackages' : ActorMethod<
     [string],
-    Array<[PackageName__1, Version]>
+    Array<[PackageName__1, PackageVersion]>
   >,
   'getDownloadTrendByPackageId' : ActorMethod<
     [PackageId],
@@ -164,12 +170,16 @@ export interface _SERVICE {
     [PackageName__1],
     Array<DownloadsSnapshot__1>
   >,
-  'getFileIds' : ActorMethod<[PackageName__1, Ver], Result_6>,
+  'getFileIds' : ActorMethod<[PackageName__1, PackageVersion], Result_7>,
+  'getHighestSemverBatch' : ActorMethod<
+    [Array<[PackageName__1, PackageVersion, SemverPart]>],
+    Result_6
+  >,
   'getHighestVersion' : ActorMethod<[PackageName__1], Result_5>,
   'getMostDownloadedPackages' : ActorMethod<[], Array<PackageSummary>>,
   'getMostDownloadedPackagesIn7Days' : ActorMethod<[], Array<PackageSummary>>,
   'getNewPackages' : ActorMethod<[], Array<PackageSummary>>,
-  'getPackageDetails' : ActorMethod<[PackageName__1, Ver], Result_4>,
+  'getPackageDetails' : ActorMethod<[PackageName__1, PackageVersion], Result_4>,
   'getPackagesByCategory' : ActorMethod<
     [],
     Array<[string, Array<PackageSummary>]>
@@ -179,7 +189,8 @@ export interface _SERVICE {
   'getTotalDownloads' : ActorMethod<[], bigint>,
   'getTotalPackages' : ActorMethod<[], bigint>,
   'getUser' : ActorMethod<[Principal], [] | [User__1]>,
-  'notifyInstall' : ActorMethod<[PackageName__1, Ver], undefined>,
+  'notifyInstall' : ActorMethod<[PackageName__1, PackageVersion], undefined>,
+  'restore' : ActorMethod<[bigint, bigint], undefined>,
   'search' : ActorMethod<
     [Text, [] | [bigint], [] | [bigint]],
     [Array<PackageSummary>, PageCount]

package/declarations/main/main.did.js

@@ -4,7 +4,7 @@ export const idlFactory = ({ IDL }) => {
   const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
   const Text = IDL.Text;
   const PackageName__1 = IDL.Text;
-  const Version = IDL.Text;
+  const PackageVersion = IDL.Text;
   const PackageId = IDL.Text;
   const Time = IDL.Int;
   const DownloadsSnapshot__1 = IDL.Record({
@@ -12,10 +12,18 @@ export const idlFactory = ({ IDL }) => {
     'endTime' : Time,
     'downloads' : IDL.Nat,
   });
-  const Ver = IDL.Text;
   const FileId = IDL.Text;
-  const Result_6 = IDL.Variant({ 'ok' : IDL.Vec(FileId), 'err' : Err });
-  const Result_5 = IDL.Variant({ 'ok' : Ver, 'err' : Err });
+  const Result_7 = IDL.Variant({ 'ok' : IDL.Vec(FileId), 'err' : Err });
+  const SemverPart = IDL.Variant({
+    'major' : IDL.Null,
+    'minor' : IDL.Null,
+    'patch' : IDL.Null,
+  });
+  const Result_6 = IDL.Variant({
+    'ok' : IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion)),
+    'err' : Err,
+  });
+  const Result_5 = IDL.Variant({ 'ok' : PackageVersion, 'err' : Err });
   const User = IDL.Record({
     'id' : IDL.Principal,
     'emailVerified' : IDL.Bool,
@@ -138,14 +146,16 @@ export const idlFactory = ({ IDL }) => {
   const PublishingErr = IDL.Text;
   const Result_1 = IDL.Variant({ 'ok' : PublishingId, 'err' : PublishingErr });
   return IDL.Service({
+    'backup' : IDL.Func([], [], []),
     'claimAirdrop' : IDL.Func([IDL.Principal], [IDL.Text], []),
     'finishPublish' : IDL.Func([PublishingId], [Result], []),
     'getAirdropAmount' : IDL.Func([], [IDL.Nat], ['query']),
     'getAirdropAmountAll' : IDL.Func([], [IDL.Nat], ['query']),
     'getApiVersion' : IDL.Func([], [Text], ['query']),
+    'getBackupCanisterId' : IDL.Func([], [IDL.Principal], ['query']),
     'getDefaultPackages' : IDL.Func(
         [IDL.Text],
-        [IDL.Vec(IDL.Tuple(PackageName__1, Version))],
+        [IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion))],
         ['query'],
       ),
     'getDownloadTrendByPackageId' : IDL.Func(
@@ -158,7 +168,16 @@ export const idlFactory = ({ IDL }) => {
         [IDL.Vec(DownloadsSnapshot__1)],
         ['query'],
       ),
-    'getFileIds' : IDL.Func([PackageName__1, Ver], [Result_6], ['query']),
+    'getFileIds' : IDL.Func(
+        [PackageName__1, PackageVersion],
+        [Result_7],
+        ['query'],
+      ),
+    'getHighestSemverBatch' : IDL.Func(
+        [IDL.Vec(IDL.Tuple(PackageName__1, PackageVersion, SemverPart))],
+        [Result_6],
+        ['query'],
+      ),
     'getHighestVersion' : IDL.Func([PackageName__1], [Result_5], ['query']),
     'getMostDownloadedPackages' : IDL.Func(
         [],
@@ -172,7 +191,7 @@ export const idlFactory = ({ IDL }) => {
       ),
     'getNewPackages' : IDL.Func([], [IDL.Vec(PackageSummary)], ['query']),
     'getPackageDetails' : IDL.Func(
-        [PackageName__1, Ver],
+        [PackageName__1, PackageVersion],
         [Result_4],
         ['query'],
       ),
@@ -194,7 +213,12 @@ export const idlFactory = ({ IDL }) => {
     'getTotalDownloads' : IDL.Func([], [IDL.Nat], ['query']),
     'getTotalPackages' : IDL.Func([], [IDL.Nat], ['query']),
     'getUser' : IDL.Func([IDL.Principal], [IDL.Opt(User__1)], ['query']),
-    'notifyInstall' : IDL.Func([PackageName__1, Ver], [], ['oneway']),
+    'notifyInstall' : IDL.Func(
+        [PackageName__1, PackageVersion],
+        [],
+        ['oneway'],
+      ),
+    'restore' : IDL.Func([IDL.Nat, IDL.Nat], [], []),
     'search' : IDL.Func(
         [Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],
         [IDL.Vec(PackageSummary), PageCount],

package/dist/cli.js

@@ -20,6 +20,8 @@ import { remove } from './commands/remove.js';
 import { getUserProp, setUserProp } from './commands/user.js';
 import { bump } from './commands/bump.js';
 import { sync } from './commands/sync.js';
+import { outdated } from './commands/outdated.js';
+import { update } from './commands/update.js';
 // import {docs} from './commands/docs.js';
 program.name('mops');
 // --version
@@ -27,10 +29,11 @@ let packageJson = JSON.parse(fs.readFileSync(new URL('package.json', import.meta
 program.version(`CLI ${packageJson.version}\nAPI ${apiVersion}`, '-v --version');
 // init
 program
-    .command('init [name]')
-    .description('Create mops.toml')
-    .action(async (name) => {
-    await init(name);
+    .command('init')
+    .description('Initialize a new project or package in the current directory')
+    .option('-y, --yes', 'Accept all defaults')
+    .action(async (options) => {
+    await init(options);
 });
 // add
 program
@@ -99,7 +102,7 @@ program
 program
     .command('set-network <network>')
     .alias('sn')
-    .description('Set network local|dev|ic')
+    .description('Set network local|staging|ic')
     .action(async (network) => {
     await setNetwork(network);
     console.log(`Selected '${network}' network`);
@@ -265,7 +268,7 @@ program
     .command('bump [major|minor|patch]')
     .description('Bump current package version')
     .action(async (part) => {
-    bump(part);
+    await bump(part);
 });
 // sync
 program
@@ -274,4 +277,18 @@ program
     .action(async () => {
     await sync();
 });
+// outdated
+program
+    .command('outdated')
+    .description('Print outdated dependencies specified in mops.toml')
+    .action(async () => {
+    await outdated();
+});
+// update
+program
+    .command('update [pkg]')
+    .description('Update dependencies specified in mops.toml')
+    .action(async (pkg) => {
+    await update(pkg);
+});
 program.parse();

package/dist/commands/available-updates.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../types.js';
+export declare function getAvailableUpdates(config: Config, pkg?: string): Promise<Array<[string, string, string]>>;

package/dist/commands/available-updates.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { mainActor } from '../mops.js';
+// [pkg, oldVersion, newVersion]
+export async function getAvailableUpdates(config, pkg) {
+    let deps = Object.values(config.dependencies || {});
+    let devDeps = Object.values(config['dev-dependencies'] || {});
+    let allDeps = [...deps, ...devDeps].filter((dep) => dep.version);
+    let depsToUpdate = pkg ? allDeps.filter((dep) => dep.name === pkg) : allDeps;
+    let getCurrentVersion = (pkg) => {
+        for (let dep of allDeps) {
+            if (dep.name === pkg && dep.version) {
+                return dep.version;
+            }
+        }
+        return '';
+    };
+    let actor = await mainActor();
+    let res = await actor.getHighestSemverBatch(depsToUpdate.map((dep) => [dep.name, dep.version || '', { major: null }]));
+    if ('err' in res) {
+        console.log(chalk.red('Error:'), res.err);
+        process.exit(1);
+    }
+    return res.ok.filter((dep) => dep[1] !== getCurrentVersion(dep[0])).map((dep) => [dep[0], getCurrentVersion(dep[0]), dep[1]]);
+}

package/dist/commands/init.d.ts

@@ -1 +1,3 @@
-export declare function init(name?: string): Promise<void>;
+export declare function init({ yes }?: {
+    yes?: boolean | undefined;
+}): Promise<void>;

package/dist/commands/init.js

@@ -1,59 +1,169 @@
 import { execSync } from 'node:child_process';
 import path from 'node:path';
-import fs from 'node:fs';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import chalk from 'chalk';
-import { checkApiCompatibility, mainActor, readDfxJson, writeConfig } from '../mops.js';
+import prompts from 'prompts';
+import { checkApiCompatibility, mainActor, writeConfig } from '../mops.js';
 import { installAll } from './install-all.js';
 import { readVesselConfig } from '../vessel.js';
-export async function init(name = '') {
+import { template } from './template.js';
+export async function init({ yes = false } = {}) {
     let configFile = path.join(process.cwd(), 'mops.toml');
-    let exists = fs.existsSync(configFile);
+    let exists = existsSync(configFile);
     if (exists) {
         console.log(chalk.yellow('mops.toml already exists'));
         return;
     }
     console.log('Initializing...');
     let config = {};
+    if (yes) {
+        await applyInit({
+            type: 'project',
+            config,
+            setupWorkflow: true,
+            addTest: false,
+            copyrightOwner: '',
+        });
+        return;
+    }
+    // migrate from vessel
+    let vesselFile = path.join(process.cwd(), 'vessel.dhall');
     let vesselConfig = { dependencies: [], 'dev-dependencies': [] };
-    let deps = {};
-    const vesselFile = path.join(process.cwd(), 'vessel.dhall');
-    if (fs.existsSync(vesselFile)) {
+    if (existsSync(vesselFile)) {
         console.log('Reading vessel.dhall file');
-        const res = await readVesselConfig(process.cwd(), { cache: false });
+        let res = await readVesselConfig(process.cwd(), { cache: false });
         if (res) {
             vesselConfig = { ...res };
         }
     }
     if (vesselConfig.dependencies) {
+        let deps = {};
         deps = {};
         for (const dep of (vesselConfig.dependencies || [])) {
             deps[dep.name] = dep;
         }
+        if (Object.keys(deps).length) {
+            config.dependencies = deps;
+        }
     }
-    // lib mode
-    if (name) {
+    let promptsConfig = {
+        onCancel() {
+            console.log('aborted');
+            process.exit(0);
+        }
+    };
+    // type
+    let { type } = await prompts({
+        type: 'select',
+        name: 'type',
+        message: 'Select type:',
+        choices: [
+            { title: `Project ${chalk.dim('(I just want to use mops packages in my project)')}`, value: 'project' },
+            { title: `Package ${chalk.dim('(I plan to publish this package on mops)')}`, value: 'package' },
+        ],
+    }, promptsConfig);
+    let addTest = false;
+    let copyrightOwner = '';
+    // package details
+    if (type === 'package') {
+        let res = await prompts([
+            {
+                type: 'text',
+                name: 'name',
+                message: 'Enter package name:',
+                initial: '',
+            },
+            {
+                type: 'text',
+                name: 'description',
+                message: 'Enter package description:',
+                initial: '',
+            },
+            {
+                type: 'text',
+                name: 'repository',
+                message: 'Enter package repository url:',
+                initial: '',
+            },
+            {
+                type: 'text',
+                name: 'keywords',
+                message: 'Enter keywords separated by spaces:',
+                initial: '',
+            },
+            {
+                type: 'select',
+                name: 'license',
+                message: 'Choose a license:',
+                choices: [
+                    { title: 'MIT', value: 'MIT' },
+                    { title: 'Apache-2.0', value: 'Apache-2.0' },
+                ],
+                initial: 0,
+            },
+            {
+                type: 'text',
+                name: 'copyrightOwner',
+                message: 'Enter license copyright owner:',
+                initial: '',
+            },
+            {
+                type: 'confirm',
+                name: 'addTest',
+                message: `Add example test file? ${chalk.dim('(test/lib.test.mo)')}`,
+                initial: true,
+            },
+        ], promptsConfig);
         config.package = {
-            name,
-            version: '0.1.0',
-            description: '',
-            repository: '',
+            name: (res.name || '').trim(),
+            version: '1.0.0',
+            description: (res.description || '').trim(),
+            repository: (res.repository || '').trim(),
+            keywords: [...new Set(res.keywords.split(' ').filter(Boolean))],
+            license: (res.license || '').trim(),
         };
-        if (deps) {
-            config.dependencies = deps;
-        }
-        writeConfig(config, configFile);
-        if (Object.keys(config.dependencies || {}).length) {
-            await installAll({ verbose: true });
+        addTest = res.addTest;
+        copyrightOwner = res.copyrightOwner;
+    }
+    // GitHub workflow
+    let { setupWorkflow } = await prompts({
+        type: 'confirm',
+        name: 'setupWorkflow',
+        message: `Setup GitHub workflow? ${chalk.dim('(run `mops test` on push)')}`,
+        initial: true,
+    }, promptsConfig);
+    await applyInit({
+        type,
+        config,
+        setupWorkflow,
+        addTest,
+        copyrightOwner,
+    });
+}
+async function applyInit({ type, config, setupWorkflow, addTest, copyrightOwner }) {
+    // set packtool in dfx.json
+    let dfxJson = path.resolve(process.cwd(), 'dfx.json');
+    let dfxJsonData;
+    if (existsSync(dfxJson)) {
+        let dfxJsonText = readFileSync(dfxJson).toString();
+        dfxJsonData = JSON.parse(dfxJsonText);
+        console.log('Setting packtool in dfx.json...');
+        dfxJsonData.defaults = dfxJsonData.defaults || {};
+        dfxJsonData.defaults.build = dfxJsonData.defaults.build || {};
+        if (dfxJsonData.defaults.build.packtool !== 'mops sources') {
+            dfxJsonData.defaults.build.packtool = 'mops sources';
+            let indent = dfxJsonText.match(/([ \t]+)"/)?.[1] || '  ';
+            writeFileSync(path.join(process.cwd(), 'dfx.json'), JSON.stringify(dfxJsonData, null, indent));
+            console.log(chalk.green('packtool set to "mops sources"'));
         }
     }
-    // project mode
-    if (!name) {
+    // get default packages
+    if (type === 'project') {
         let compatible = await checkApiCompatibility();
         if (!compatible) {
             return;
         }
-        let dfxJson = readDfxJson();
-        let dfxVersion = dfxJson?.dfx || '';
+        let dfxVersion = dfxJsonData?.dfx || '';
         if (!dfxVersion) {
             try {
                 let res = execSync('dfx --version').toString();
@@ -64,19 +174,54 @@ export async function init(name = '') {
             }
             catch { }
         }
+        console.log(`Fetching default packages for dfx ${dfxVersion}...`);
         let actor = await mainActor();
         let defaultPackages = await actor.getDefaultPackages(dfxVersion);
         if (!config.dependencies) {
             config.dependencies = {};
         }
-        if (deps) {
-            config.dependencies = deps;
-        }
         for (let [name, version] of defaultPackages) {
             config.dependencies[name] = { name, version };
         }
-        writeConfig(config, configFile);
+    }
+    // save config
+    let configFile = path.join(process.cwd(), 'mops.toml');
+    writeConfig(config, configFile);
+    console.log(chalk.green('Created'), 'mops.toml');
+    // add src/lib.mo
+    if (type === 'package' && !existsSync(path.join(process.cwd(), 'src'))) {
+        await template('lib.mo');
+    }
+    // add src/lib.test.mo
+    if (addTest && !existsSync(path.join(process.cwd(), 'test'))) {
+        await template('lib.test.mo');
+    }
+    // add license
+    if (config.package?.license) {
+        await template(`license:${config.package.license}`, { copyrightOwner });
+    }
+    // add readme
+    if (type === 'package') {
+        await template('readme');
+    }
+    // add GitHub workflow
+    if (setupWorkflow) {
+        await template('github-workflow:mops-test');
+    }
+    // add .mops to .gitignore
+    {
+        let gitignore = path.join(process.cwd(), '.gitignore');
+        let gitignoreData = existsSync(gitignore) ? readFileSync(gitignore).toString() : '';
+        let lf = gitignoreData.endsWith('\n') ? '\n' : '';
+        if (!gitignoreData.includes('.mops')) {
+            writeFileSync(gitignore, `${gitignoreData}\n.mops${lf}`.trimStart());
+            console.log(chalk.green('Added'), '.mops to .gitignore');
+        }
+    }
+    // install deps
+    if (Object.keys(config.dependencies || {}).length) {
+        console.log('Installing dependencies...');
         await installAll({ verbose: true });
     }
-    console.log(chalk.green('mops.toml has been created'));
+    console.log(chalk.green('Done!'));
 }

package/dist/commands/outdated.d.ts

@@ -0,0 +1 @@
+export declare function outdated(): Promise<void>;

package/dist/commands/outdated.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { checkConfigFile, readConfig } from '../mops.js';
+import { getAvailableUpdates } from './available-updates.js';
+export async function outdated() {
+    if (!checkConfigFile()) {
+        return;
+    }
+    let config = readConfig();
+    let available = await getAvailableUpdates(config);
+    if (available.length === 0) {
+        console.log(chalk.green('All dependencies are up to date!'));
+    }
+    else {
+        console.log('Available updates:');
+        for (let dep of available) {
+            console.log(`${dep[0]} ${chalk.yellow(dep[1])} -> ${chalk.green(dep[2])}`);
+        }
+    }
+}

package/dist/commands/template.d.ts

@@ -1 +1 @@
-export declare function template(): Promise<void>;
+export declare function template(templateName?: string, options?: any): Promise<void>;