ic-mops 0.22.0 → 0.24.0

package/README.md

@@ -17,28 +17,16 @@ npm i -g ic-mops
 
 ## Install Packages
 
-### 1. Configure dfx.json
-Add `mops` as a packtool to your `dfx.json`
-
-```json
-{
-  "defaults": {
-    "build": {
-      "packtool": "mops sources"
-    }
-  }
-}
-```
-
-### 2. Initialize
+### 1. Initialize
 Run this command in the root directory of your project (where is `dfx.json` placed)
+
 If there are Vessel config files, mops will migrate packages from `vessel.dhall` to `mops.toml`
 
 ```
 mops init
 ```
 
-### 3. Install Motoko Packages
+### 2. Install Motoko Packages
 Use `mops add <package_name>` to install a specific package and save it to `mops.toml`
 
 ```
@@ -65,7 +53,7 @@ Use `mops install` to install all packages specified in `mops.toml`
 mops install
 ```
 
-### 4. Import Package
+### 3. Import Package
 Now you can import installed packages in your Motoko code
 
 ```motoko
@@ -92,10 +80,10 @@ mops import-identity -- "$(dfx identity export mops)"
 ```
 
 ### 2. Initialize
-Run this command in your package root
+Run this command in your package root and select type "Package"
 
 ```
-mops init <your_package_name>
+mops init
 ```
 
 Edit `description` and `repository` fields in `mops.toml` file.

package/cli.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import fs from 'node:fs';
-import {program} from 'commander';
+import {program, Argument} from 'commander';
 import chalk from 'chalk';
 import {Principal} from '@dfinity/principal';
 
@@ -21,6 +21,7 @@ import {selfUpdate} from './commands/self-update.js';
 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 {docs} from './commands/docs.js';
 
 program.name('mops');
@@ -31,10 +32,11 @@ program.version(`CLI ${packageJson.version}\nAPI ${apiVersion}`, '-v --version')
 
 // init
 program
-	.command('init [name]')
-	.description('Create mops.toml')
-	.action(async (name: string) => {
-		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
@@ -110,7 +112,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`);
@@ -166,8 +168,9 @@ program
 
 // cache
 program
-	.command('cache [sub-command]')
+	.command('cache')
 	.description('Manage cache')
+	.addArgument(new Argument('<sub>').choices(['size', 'clean']))
 	.action(async (sub) => {
 		if (sub == 'clean') {
 			await cleanCache();
@@ -177,9 +180,6 @@ program
 			let size = await cacheSize();
 			console.log('Cache size is ' + size);
 		}
-		else {
-			console.log('Unknown sub command. Available sub commands: clean, size');
-		}
 	});
 
 // test
@@ -236,7 +236,10 @@ program
 
 // user
 program
-	.command('user set|get <prop> [value]')
+	.command('user')
+	.addArgument(new Argument('<sub>').choices(['set', 'get']))
+	.addArgument(new Argument('<prop>').choices(['name', 'site', 'email', 'github', 'twitter']))
+	.addArgument(new Argument('[value]'))
 	.description('User settings')
 	.action(async (sub, prop, value) => {
 		if (sub == 'get') {
@@ -249,9 +252,6 @@ program
 			}
 			await setUserProp(prop, value);
 		}
-		else {
-			console.log('Unknown sub command. Available sub commands: set, get');
-		}
 	});
 
 // airdrop
@@ -294,4 +294,12 @@ program
 		bump(part);
 	});
 
+// sync
+program
+	.command('sync')
+	.description('Add missing packages and remove unused packages')
+	.action(async () => {
+		await sync();
+	});
+
 program.parse();

package/commands/init.ts

@@ -1,15 +1,18 @@
 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 {VesselConfig, readVesselConfig} from '../vessel.js';
 import {Config, Dependencies} from '../types.js';
+import {template} from './template.js';
 
-export async function init(name = '') {
+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;
@@ -18,56 +21,179 @@ export async function init(name = '') {
 	console.log('Initializing...');
 
 	let config: Config = {};
-	let vesselConfig: VesselConfig = {dependencies: [], 'dev-dependencies': []};
-	let deps: Dependencies = {};
 
-	const vesselFile = path.join(process.cwd(), 'vessel.dhall');
+	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: VesselConfig = {dependencies: [], 'dev-dependencies': []};
 
-	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: Dependencies = {};
 		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))] as string[],
+			license: (res.license || '').trim(),
 		};
 
-		if (deps) {
-			config.dependencies = deps;
-		}
+		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,
+	});
+}
 
-		writeConfig(config, configFile);
+type ApplyInitOptions = {
+	type: 'project' | 'package';
+	config: Config;
+	setupWorkflow: boolean;
+	addTest: boolean;
+	copyrightOwner: string;
+}
 
-		if (Object.keys(config.dependencies || {}).length) {
-			await installAll({verbose: true});
+async function applyInit({type, config, setupWorkflow, addTest, copyrightOwner} : ApplyInitOptions) {
+	// 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();
@@ -79,6 +205,7 @@ export async function init(name = '') {
 			catch {}
 		}
 
+		console.log(`Fetching default packages for dfx ${dfxVersion}...`);
 		let actor = await mainActor();
 		let defaultPackages = await actor.getDefaultPackages(dfxVersion);
 
@@ -86,18 +213,57 @@ export async function init(name = '') {
 			config.dependencies = {};
 		}
 
-		if (deps) {
-			config.dependencies = deps;
-		}
-
 		for (let [name, version] of defaultPackages) {
 			config.dependencies[name] = {name, version};
 		}
+	}
+
+	// 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');
+	}
 
-		writeConfig(config, configFile);
+	// 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/commands/remove.ts

@@ -77,7 +77,7 @@ export async function remove(name: string, {dev = false, verbose = false, dryRun
 			pkgDir = formatDir(dep.name, dep.version);
 		}
 		if (pkgDir && fs.existsSync(pkgDir)) {
-			dryRun || deleteSync([`${pkgDir}`]);
+			dryRun || deleteSync([`${pkgDir}`], {force: true});
 			verbose && console.log(`Removed local cache ${pkgDir}`);
 		}
 	}

package/commands/sync.ts

@@ -0,0 +1,98 @@
+import path from 'node:path';
+import {execSync} from 'node:child_process';
+import {globSync} from 'glob';
+import chalk from 'chalk';
+import {checkConfigFile, getRootDir, readConfig} from '../mops.js';
+import {add} from './add.js';
+import {remove} from './remove.js';
+
+let ignore = [
+	'**/node_modules/**',
+	'**/.vessel/**',
+	'**/.git/**',
+	'**/.mops/**',
+	'**/test/**',
+	'**/*.test.mo',
+];
+
+let mocPath = '';
+function getMocPath(): string {
+	if (!mocPath) {
+		mocPath = process.env.DFX_MOC_PATH || '';
+	}
+	if (!mocPath) {
+		try {
+			mocPath = execSync('dfx cache show').toString().trim() + '/moc';
+		}
+		catch {}
+	}
+	if (!mocPath) {
+		mocPath = 'moc';
+	}
+	return mocPath;
+}
+
+async function getUsedPackages(): Promise<string[]> {
+	let rootDir = getRootDir();
+	let files = globSync('**/*.mo', {
+		cwd: rootDir,
+		nocase: true,
+		ignore: ignore,
+	});
+
+	let packages: Set<string> = new Set;
+
+	for (let file of files) {
+		let deps: string[] = execSync(`${getMocPath()} --print-deps ${path.join(rootDir, file)}`).toString().trim().split('\n');
+
+		for (let dep of deps) {
+			if (dep.startsWith('mo:') && !dep.startsWith('mo:prim') && !dep.startsWith('mo:⛔')) {
+				packages.add(dep.replace(/^mo:([^/]+).*$/, '$1'));
+			}
+		}
+	}
+
+	return [...packages];
+}
+
+async function getMissingPackages(): Promise<string[]> {
+	let config = readConfig();
+	let allDeps = [...Object.keys(config.dependencies || {}), ...Object.keys(config['dev-dependencies'] || {})];
+	let missing = new Set(await getUsedPackages());
+	for (let pkg of allDeps) {
+		missing.delete(pkg);
+	}
+	return [...missing];
+}
+
+async function getUnusedPackages(): Promise<string[]> {
+	let config = readConfig();
+	let allDeps = new Set([...Object.keys(config.dependencies || {})]);
+	let used = await getUsedPackages();
+	for (let pkg of used) {
+		allDeps.delete(pkg);
+	}
+	return [...allDeps];
+}
+
+export async function sync() {
+	if (!checkConfigFile()) {
+		return;
+	}
+
+	let missing = await getMissingPackages();
+	let unused = await getUnusedPackages();
+
+	missing.length && console.log(`${chalk.yellow('Missing packages:')} ${missing.join(', ')}`);
+	unused.length && console.log(`${chalk.yellow('Unused packages:')} ${unused.join(', ')}`);
+
+	// add missing packages
+	for (let pkg of missing) {
+		await add(pkg);
+	}
+
+	// remove unused packages
+	for (let pkg of unused) {
+		await remove(pkg);
+	}
+}

package/commands/template.ts

@@ -2,29 +2,97 @@ import fs from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import prompts from 'prompts';
-import {getRootDir} from '../mops.js';
+import camelCase from 'camelcase';
+import {getRootDir, readConfig} from '../mops.js';
 
-export async function template() {
-	let res = await prompts({
-		type: 'select',
-		name: 'value',
-		message: 'Select template:',
-		choices: [
-			{title: 'GitHub Workflow to run \'mops test\'', value: 'github-workflow:mops-test'},
-			{title: '× Cancel', value: ''},
-		],
-		initial: 0,
-	});
+export async function template(templateName?: string, options: any = {}) {
+	if (!templateName) {
+		let res = await prompts({
+			type: 'select',
+			name: 'value',
+			message: 'Select template:',
+			choices: [
+				{title: 'README.md', value: 'readme'},
+				{title: 'src/lib.mo', value: 'lib.mo'},
+				{title: 'test/lib.test.mo', value: 'lib.test.mo'},
+				{title: 'License MIT', value: 'license:MIT'},
+				{title: 'License Apache-2.0', value: 'license:Apache-2.0'},
+				{title: 'GitHub Workflow to run \'mops test\'', value: 'github-workflow:mops-test'},
+				{title: '× Cancel', value: ''},
+			],
+			initial: 0,
+		});
+		templateName = res.value;
+	}
 
-	if (res.value === 'github-workflow:mops-test') {
+	if (templateName === 'github-workflow:mops-test') {
 		let dest = path.resolve(getRootDir(), '.github/workflows/mops-test.yml');
 		if (fs.existsSync(dest)) {
-			console.log(chalk.yellow('Workflow already exists:'), dest);
+			console.log(chalk.yellow('Workflow already exists:'), path.relative(getRootDir(), dest));
 			return;
 		}
 		let mopsTestYml = new URL('../templates/mops-test.yml', import.meta.url);
 		fs.mkdirSync(path.resolve(getRootDir(), '.github/workflows'), {recursive: true});
 		fs.copyFileSync(mopsTestYml, dest);
-		console.log(chalk.green('Workflow created:'), dest);
+		console.log(chalk.green('Created'), path.relative(getRootDir(), dest));
+	}
+	else if (templateName?.startsWith('license:')) {
+		let dest = path.resolve(getRootDir(), 'LICENSE');
+		if (fs.existsSync(dest)) {
+			console.log(chalk.yellow('LICENSE already exists'));
+			return;
+		}
+
+		let setYearAndOwner = (file: string) => {
+			let license = fs.readFileSync(file).toString();
+			license = license.replace(/<year>/g, new Date().getFullYear().toString());
+			if (options.copyrightOwner) {
+				license = license.replace(/<copyright-owner>/g, options.copyrightOwner);
+			}
+			fs.writeFileSync(file, license);
+		};
+
+		if (templateName === 'license:MIT') {
+			fs.copyFileSync(new URL('../templates/licenses/MIT', import.meta.url), path.resolve(getRootDir(), 'LICENSE'));
+			setYearAndOwner(path.resolve(getRootDir(), 'LICENSE'));
+			console.log(chalk.green('Created'), path.relative(getRootDir(), 'LICENSE'));
+		}
+		else if (templateName === 'license:Apache-2.0') {
+			fs.copyFileSync(new URL('../templates/licenses/Apache-2.0', import.meta.url), path.resolve(getRootDir(), 'LICENSE'));
+			fs.copyFileSync(new URL('../templates/licenses/Apache-2.0-NOTICE', import.meta.url), path.resolve(getRootDir(), 'NOTICE'));
+			setYearAndOwner(path.resolve(getRootDir(), 'NOTICE'));
+			console.log(chalk.green('Created'), path.relative(getRootDir(), 'LICENSE'));
+			console.log(chalk.green('Created'), path.relative(getRootDir(), 'NOTICE'));
+		}
+	}
+	else if (templateName === 'lib.mo') {
+		fs.mkdirSync(path.join(getRootDir(), 'src'), {recursive: true});
+		fs.copyFileSync(new URL('../templates/src/lib.mo', import.meta.url), path.resolve(getRootDir(), 'src/lib.mo'));
+		console.log(chalk.green('Created'), path.relative(getRootDir(), 'src/lib.mo'));
+	}
+	else if (templateName === 'lib.test.mo') {
+		fs.mkdirSync(path.join(getRootDir(), 'test'), {recursive: true});
+		fs.copyFileSync(new URL('../templates/test/lib.test.mo', import.meta.url), path.resolve(getRootDir(), 'test/lib.test.mo'));
+		console.log(chalk.green('Created'), path.relative(getRootDir(), 'test/lib.test.mo'));
+	}
+	else if (templateName === 'readme') {
+		let dest = path.resolve(getRootDir(), 'README.md');
+		if (fs.existsSync(dest)) {
+			console.log(chalk.yellow('README.md already exists'));
+			return;
+		}
+		fs.copyFileSync(new URL('../templates/README.md', import.meta.url), dest);
+
+		let config = readConfig();
+
+		let data = fs.readFileSync(dest).toString();
+		data = data.replace(/<year>/g, new Date().getFullYear().toString());
+		if (config.package?.name) {
+			data = data.replace(/<name>/g, config.package.name);
+			data = data.replace(/<import-name>/g, camelCase(config.package.name, {pascalCase: true}));
+		}
+		fs.writeFileSync(dest, data);
+
+		console.log(chalk.green('Created'), path.relative(getRootDir(), 'README.md'));
 	}
 }