ic-mops 0.34.4 → 0.36.0

package/cli.ts

@@ -3,15 +3,13 @@
 import fs from 'node:fs';
 import {program, Argument, Option} from 'commander';
 import chalk from 'chalk';
-import {Principal} from '@dfinity/principal';
 
 import {init} from './commands/init.js';
 import {publish} from './commands/publish.js';
 import {importPem} from './commands/import-identity.js';
 import {sources} from './commands/sources.js';
-import {checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile, getIdentity} from './mops.js';
+import {checkApiCompatibility, setNetwork, apiVersion, checkConfigFile, getNetworkFile} from './mops.js';
 import {getNetwork} from './api/network.js';
-import {mainActor} from './api/actors.js';
 import {whoami} from './commands/whoami.js';
 import {installAll} from './commands/install-all.js';
 import {search} from './commands/search.js';
@@ -62,7 +60,7 @@ program
 	.description('Install the package and save it to mops.toml')
 	.option('--dev')
 	.option('--verbose')
-	.addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
 	.action(async (pkg, options) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
@@ -78,7 +76,7 @@ program
 	.option('--dev', 'Remove from dev-dependencies instead of dependencies')
 	.option('--verbose', 'Show more information')
 	.option('--dry-run', 'Do not actually remove anything')
-	.addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
 	.action(async (pkg, options) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
@@ -92,7 +90,7 @@ program
 	.alias('i')
 	.description('Install all dependencies specified in mops.toml')
 	.option('--verbose')
-	.addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'check', 'ignore']))
+	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['check', 'update', 'ignore']))
 	.action(async (pkg, options) => {
 		if (!checkConfigFile()) {
 			process.exit(1);
@@ -167,7 +165,7 @@ program
 		if (!checkConfigFile()) {
 			process.exit(1);
 		}
-		await installAll({silent: true, lockfile: 'ignore'});
+		await installAll({silent: true, lock: 'ignore'});
 		let sourcesArr = await sources(options);
 		console.log(sourcesArr.join('\n'));
 	});
@@ -212,7 +210,7 @@ program
 	.addOption(new Option('--mode <mode>', 'Test mode').choices(['interpreter', 'wasi']).default('interpreter'))
 	.option('-w, --watch', 'Enable watch mode')
 	.action(async (filter, options) => {
-		await installAll({silent: true, lockfile: 'ignore'});
+		await installAll({silent: true, lock: 'ignore'});
 		await test(filter, options);
 	});
 
@@ -220,13 +218,14 @@ program
 program
 	.command('bench [filter]')
 	.description('Run benchmarks')
+	.addOption(new Option('--replica <replica>', 'Which replica to use to run benchmarks').choices(['dfx', 'pocket-ic']).default('dfx'))
+	.addOption(new Option('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('copying'))
 	.addOption(new Option('--save', 'Save benchmark results to .bench/<filename>.json'))
 	.addOption(new Option('--compare', 'Run benchmark and compare results with .bench/<filename>.json'))
-	.addOption(new Option('--gc <gc>', 'Garbage collector').choices(['copying', 'compacting', 'generational', 'incremental']).default('incremental'))
 	// .addOption(new Option('--force-gc', 'Force GC'))
 	.addOption(new Option('--verbose', 'Show more information'))
 	.action(async (filter, options) => {
-		await installAll({silent: true, lockfile: 'ignore'});
+		await installAll({silent: true, lock: 'ignore'});
 		await bench(filter, options);
 	});
 
@@ -287,39 +286,6 @@ program
 		}
 	});
 
-// temp: airdrop
-program
-	.command('airdrop <check|claim> [canister]')
-	.action(async (sub, canister) => {
-		let identity = await getIdentity();
-		let main = await mainActor(identity);
-		if (sub === 'check') {
-			let amount = await main.getAirdropAmount();
-			if (amount === 0n) {
-				console.log('No airdrop available');
-				return;
-			}
-			console.log(`You can claim ${Number(amount) / 1_000_000_000_000} TCycles`);
-		}
-		else if (sub === 'claim') {
-			let principal;
-			try {
-				principal = Principal.fromText(canister);
-			}
-			catch (err) {
-				console.log('Invalid canister id');
-				console.log(err);
-				return;
-			}
-			console.log('Sending cycles to the canister ' + canister);
-			let res = await main.claimAirdrop(principal);
-			console.log(res);
-		}
-		else {
-			console.log('Unknown sub command. Available sub commands: check, claim');
-		}
-	});
-
 // bump
 program
 	.command('bump [major|minor|patch]')
@@ -332,7 +298,7 @@ program
 program
 	.command('sync')
 	.description('Add missing packages and remove unused packages')
-	.addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
 	.action(async (options) => {
 		await sync(options);
 	});
@@ -349,7 +315,7 @@ program
 program
 	.command('update [pkg]')
 	.description('Update dependencies specified in mops.toml')
-	.addOption(new Option('--lockfile <lockfile>', 'Lockfile action').choices(['save', 'ignore']))
+	.addOption(new Option('--lock <action>', 'Lockfile action').choices(['update', 'ignore']))
 	.action(async (pkg, options) => {
 		await update(pkg, options);
 	});

package/commands/add.ts

@@ -6,16 +6,16 @@ import {getHighestVersion} from '../api/getHighestVersion.js';
 import {installFromGithub} from '../vessel.js';
 import {install} from './install.js';
 import {notifyInstalls} from '../notify-installs.js';
-// import {checkIntegrity} from '../integrity.js';
+import {checkIntegrity} from '../integrity.js';
 
 type AddOptions = {
 	verbose?: boolean;
 	dev?: boolean;
-	lockfile?: 'save' | 'ignore';
+	lock?: 'update' | 'ignore';
 };
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function add(name: string, {verbose = false, dev = false, lockfile}: AddOptions = {}, asName?: string) {
+export async function add(name: string, {verbose = false, dev = false, lock}: AddOptions = {}, asName?: string) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -109,10 +109,12 @@ export async function add(name: string, {verbose = false, dev = false, lockfile}
 
 	writeConfig(config);
 
-	// logUpdate('Checking integrity...');
+	if (lock !== 'ignore') {
+		logUpdate('Checking integrity...');
+	}
 	await Promise.all([
 		notifyInstalls(Object.keys(installedPackages)),
-		// checkIntegrity(lockfile),
+		checkIntegrity(lock),
 	]);
 
 	logUpdate.clear();

package/commands/bench-replica.ts

@@ -0,0 +1,99 @@
+import {execSync} from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import {execaCommand} from 'execa';
+import {PocketIc} from '@hadronous/pic';
+import {getRootDir} from '../mops.js';
+import {createActor, idlFactory} from '../declarations/bench/index.js';
+
+export class BenchReplica {
+	type : 'dfx' | 'pocket-ic';
+	verbose = false;
+	canisters: Record<string, {cwd: string; canisterId: string; actor: any;}> = {};
+	pocketIc?: PocketIc;
+
+	constructor(type: 'dfx' | 'pocket-ic', verbose = false) {
+		this.type = type;
+		this.verbose = verbose;
+	}
+
+	async start() {
+		console.log(`Starting ${this.type} replica...`);
+
+		if (this.type == 'dfx') {
+			await this.stop();
+			let dir = path.join(getRootDir(), '.mops/.bench');
+			fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(this.dfxJson(''), null, 2));
+			execSync('dfx start --background --clean --artificial-delay 0' + (this.verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['inherit', this.verbose ? 'inherit' : 'ignore', 'inherit']});
+		}
+		else {
+			this.pocketIc = await PocketIc.create();
+		}
+	}
+
+	async stop() {
+		if (this.type == 'dfx') {
+			let dir = path.join(getRootDir(), '.mops/.bench');
+			execSync('dfx stop' + (this.verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['pipe', this.verbose ? 'inherit' : 'ignore', 'pipe']});
+		}
+		else if (this.pocketIc) {
+			this.pocketIc.tearDown();
+		}
+	}
+
+	async deploy(name: string, wasm: string, cwd: string = process.cwd()) {
+		if (this.type === 'dfx') {
+			await execaCommand(`dfx deploy ${name} --mode reinstall --yes --identity anonymous`, {cwd, stdio: this.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
+			let canisterId = execSync(`dfx canister id ${name}`, {cwd}).toString().trim();
+			let actor = await createActor(canisterId, {
+				agentOptions: {
+					host: 'http://127.0.0.1:4944',
+				},
+			});
+			this.canisters[name] = {cwd, canisterId, actor};
+		}
+		else if (this.pocketIc) {
+			let {canisterId, actor} = await this.pocketIc.setupCanister(idlFactory, wasm);
+			this.canisters[name] = {
+				cwd,
+				canisterId: canisterId.toText(),
+				actor,
+			};
+		}
+	}
+
+	getActor(name: string): unknown {
+		return this.canisters[name]?.actor;
+	}
+
+	getCanisterId(name: string): string {
+		return this.canisters[name]?.canisterId || '';
+	}
+
+	dfxJson(canisterName: string) {
+		let canisters: Record<string, any> = {};
+		if (canisterName) {
+			canisters[canisterName] = {
+				type: 'custom',
+				wasm: 'canister.wasm',
+				candid: 'canister.did',
+			};
+		}
+
+		return {
+			version: 1,
+			canisters,
+			defaults: {
+				build: {
+					packtool: 'mops sources',
+				},
+			},
+			networks: {
+				local: {
+					type: 'ephemeral',
+					bind: '127.0.0.1:4944',
+				},
+			},
+		};
+	}
+}

package/commands/bench.ts

@@ -1,4 +1,3 @@
-import {execSync} from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -6,17 +5,19 @@ import chalk from 'chalk';
 import {globSync} from 'glob';
 import {markdownTable} from 'markdown-table';
 import logUpdate from 'log-update';
+import {execaCommand} from 'execa';
+import stringWidth from 'string-width';
 
 import {getRootDir} from '../mops.js';
 import {parallel} from '../parallel.js';
-import {createActor} from '../declarations/bench/index.js';
-import {BenchResult, BenchSchema, _SERVICE} from '../declarations/bench/bench.did.js';
 import {absToRel} from './test/utils.js';
 import {getMocVersion} from '../helpers/get-moc-version.js';
 import {getDfxVersion} from '../helpers/get-dfx-version.js';
 import {getMocPath} from '../helpers/get-moc-path.js';
 import {sources} from './sources.js';
-import {execaCommand} from 'execa';
+
+import {BenchResult, BenchSchema, _SERVICE} from '../declarations/bench/bench.did.js';
+import {BenchReplica} from './bench-replica.js';
 
 let ignore = [
 	'**/node_modules/**',
@@ -31,30 +32,36 @@ let globConfig = {
 };
 
 type BenchOptions = {
-	dfx?: string,
-	moc?: string,
-	gc?: 'copying' | 'compacting' | 'generational' | 'incremental',
-	forceGc?: boolean,
-	save?: boolean,
-	compare?: boolean,
-	verbose?: boolean,
+	replica: 'dfx' | 'pocket-ic',
+	replicaVersion: string,
+	moc: string,
+	gc: 'copying' | 'compacting' | 'generational' | 'incremental',
+	forceGc: boolean,
+	save: boolean,
+	compare: boolean,
+	verbose: boolean,
 };
 
-export async function bench(filter = '', options: BenchOptions = {}): Promise<boolean> {
+export async function bench(filter = '', optionsArg: Partial<BenchOptions> = {}): Promise<boolean> {
 	let defaultOptions: BenchOptions = {
+		replica: 'dfx',
 		moc: getMocVersion(),
-		dfx: getDfxVersion(),
-		gc: 'incremental',
+		replicaVersion: '0.0.0',
+		gc: 'copying',
 		forceGc: true,
 		save: false,
 		compare: false,
 		verbose: false,
 	};
 
-	options = {...defaultOptions, ...options};
+	let options: BenchOptions = {...defaultOptions, ...optionsArg};
+
+	options.replicaVersion = options.replica == 'dfx' ? getDfxVersion() : '1.0.0';
 
 	options.verbose && console.log(options);
 
+	let replica = new BenchReplica(options.replica, options.verbose);
+
 	let rootDir = getRootDir();
 	let globStr = '**/bench?(mark)/**/*.bench.mo';
 	if (filter) {
@@ -85,17 +92,16 @@ export async function bench(filter = '', options: BenchOptions = {}): Promise<bo
 	console.log('='.repeat(50));
 	console.log('');
 
-	console.log('Starting dfx replica...');
-	startDfx(options.verbose);
+	await replica.start();
 
 	console.log('Deploying canisters...');
 	await parallel(os.cpus().length, files, async (file: string) => {
 		try {
-			await deployBenchFile(file, options);
+			await deployBenchFile(file, options, replica);
 		}
 		catch (err) {
-			console.error('Unexpected error. Stopping dfx replica...');
-			stopDfx(options.verbose);
+			console.error('Unexpected error. Stopping replica...');
+			await replica.stop();
 			throw err;
 		}
 	});
@@ -105,17 +111,17 @@ export async function bench(filter = '', options: BenchOptions = {}): Promise<bo
 		console.log(`\nRunning ${chalk.gray(absToRel(file))}...`);
 		console.log('');
 		try {
-			await runBenchFile(file, options);
+			await runBenchFile(file, options, replica);
 		}
 		catch (err) {
-			console.error('Unexpected error. Stopping dfx replica...');
-			stopDfx(options.verbose);
+			console.error('Unexpected error. Stopping replica...');
+			await replica.stop();
 			throw err;
 		}
 	});
 
-	console.log('Stopping dfx replica...');
-	stopDfx(options.verbose);
+	console.log('Stopping replica...');
+	await replica.stop();
 
 	fs.rmSync(benchDir, {recursive: true, force: true});
 
@@ -133,55 +139,14 @@ function getMocArgs(options: BenchOptions): string {
 	return args;
 }
 
-function dfxJson(canisterName: string, options: BenchOptions = {}) {
-	options || console.log(options);
-
-	let canisters: Record<string, any> = {};
-	if (canisterName) {
-		canisters[canisterName] = {
-			type: 'custom',
-			wasm: 'canister.wasm',
-			candid: 'canister.did',
-		};
-	}
-
-	return {
-		version: 1,
-		canisters,
-		defaults: {
-			build: {
-				packtool: 'mops sources',
-			},
-		},
-		networks: {
-			local: {
-				type: 'ephemeral',
-				bind: '127.0.0.1:4944',
-			},
-		},
-	};
-}
-
-function startDfx(verbose = false) {
-	stopDfx(verbose);
-	let dir = path.join(getRootDir(), '.mops/.bench');
-	fs.writeFileSync(path.join(dir, 'dfx.json'), JSON.stringify(dfxJson(''), null, 2));
-	execSync('dfx start --background --clean --artificial-delay 0' + (verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['inherit', verbose ? 'inherit' : 'ignore', 'inherit']});
-}
-
-function stopDfx(verbose = false) {
-	let dir = path.join(getRootDir(), '.mops/.bench');
-	execSync('dfx stop' + (verbose ? '' : ' -qqqq'), {cwd: dir, stdio: ['pipe', verbose ? 'inherit' : 'ignore', 'pipe']});
-}
-
-async function deployBenchFile(file: string, options: BenchOptions = {}): Promise<void> {
+async function deployBenchFile(file: string, options: BenchOptions, replica: BenchReplica): Promise<void> {
 	let rootDir = getRootDir();
 	let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
 	let canisterName = path.parse(file).name;
 
 	// prepare temp files
 	fs.mkdirSync(tempDir, {recursive: true});
-	fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(dfxJson(canisterName, options), null, 2));
+	fs.writeFileSync(path.join(tempDir, 'dfx.json'), JSON.stringify(replica.dfxJson(canisterName), null, 2));
 
 	let benchCanisterData = fs.readFileSync(new URL('./bench/bench-canister.mo', import.meta.url), 'utf8');
 	benchCanisterData = benchCanisterData.replace('./user-bench', path.relative(tempDir, file).replace(/.mo$/g, ''));
@@ -195,18 +160,15 @@ async function deployBenchFile(file: string, options: BenchOptions = {}): Promis
 	options.verbose && console.timeEnd(`build ${canisterName}`);
 
 	// deploy canister
+	let wasm = path.join(tempDir, 'canister.wasm');
 	options.verbose && console.time(`deploy ${canisterName}`);
-	await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, {cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
+	// await execaCommand(`dfx deploy ${canisterName} --mode reinstall --yes --identity anonymous`, {cwd: tempDir, stdio: options.verbose ? 'pipe' : ['pipe', 'ignore', 'pipe']});
+	await replica.deploy(canisterName, wasm, tempDir);
 	options.verbose && console.timeEnd(`deploy ${canisterName}`);
 
 	// init bench
 	options.verbose && console.time(`init ${canisterName}`);
-	let canisterId = execSync(`dfx canister id ${canisterName}`, {cwd: tempDir}).toString().trim();
-	let actor: _SERVICE = await createActor(canisterId, {
-		agentOptions: {
-			host: 'http://127.0.0.1:4944',
-		},
-	});
+	let actor = await replica.getActor(canisterName) as _SERVICE;
 	await actor.init();
 	options.verbose && console.timeEnd(`init ${canisterName}`);
 }
@@ -216,18 +178,11 @@ type RunBenchFileResult = {
 	results: Map<string, BenchResult>,
 };
 
-async function runBenchFile(file: string, options: BenchOptions = {}): Promise<RunBenchFileResult> {
+async function runBenchFile(file: string, options: BenchOptions, replica: BenchReplica): Promise<RunBenchFileResult> {
 	let rootDir = getRootDir();
-	let tempDir = path.join(rootDir, '.mops/.bench/', path.parse(file).name);
 	let canisterName = path.parse(file).name;
 
-	let canisterId = execSync(`dfx canister id ${canisterName}`, {cwd: tempDir}).toString().trim();
-	let actor: _SERVICE = await createActor(canisterId, {
-		agentOptions: {
-			host: 'http://127.0.0.1:4944',
-		},
-	});
-
+	let actor = await replica.getActor(canisterName) as _SERVICE;
 	let schema = await actor.getSchema();
 
 	// load previous results
@@ -267,8 +222,8 @@ async function runBenchFile(file: string, options: BenchOptions = {}): Promise<R
 							let percent = (Number(res[prop]) - Number(prevRes[prop])) / Number(prevRes[prop]) * 100;
 							let sign = percent > 0 ? '+' : '';
 							let percentText = percent == 0 ? '0%' : sign + percent.toFixed(2) + '%';
-							// diff = ' (' + (percent > 0 ? chalk.red(percentText) : chalk.green(percentText)) + ')'; // alignment is broken
-							diff = ' (' + percentText + ')';
+							let color: keyof typeof chalk = percent == 0 ? 'gray' : (percent > 0 ? 'red' : 'green');
+							diff = ` (${chalk[color](percentText)})`;
 						}
 						else {
 							diff = chalk.yellow(' (no previous results)');
@@ -285,7 +240,10 @@ async function runBenchFile(file: string, options: BenchOptions = {}): Promise<R
 			resArr.push(curRow);
 		}
 
-		return markdownTable(resArr, {align: ['l', ...'r'.repeat(schema.cols.length)]});
+		return markdownTable(resArr, {
+			align: ['l', ...'r'.repeat(schema.cols.length)],
+			stringLength: stringWidth,
+		});
 	};
 
 	let printResults = () => {
@@ -297,7 +255,9 @@ async function runBenchFile(file: string, options: BenchOptions = {}): Promise<R
 		`);
 	};
 
-	printResults();
+	if (!process.env.CI) {
+		printResults();
+	}
 
 	// run all cells
 	for (let [rowIndex, row] of schema.rows.entries()) {
@@ -306,9 +266,15 @@ async function runBenchFile(file: string, options: BenchOptions = {}): Promise<R
 			// let res = await actor.runCellUpdate(BigInt(rowIndex), BigInt(colIndex));
 			let res = await actor.runCellUpdateAwait(BigInt(rowIndex), BigInt(colIndex));
 			results.set(`${row}:${col}`, res);
-			printResults();
+			if (!process.env.CI) {
+				printResults();
+			}
 		}
 	}
+
+	if (process.env.CI) {
+		printResults();
+	}
 	logUpdate.done();
 
 	// save results
@@ -317,7 +283,8 @@ async function runBenchFile(file: string, options: BenchOptions = {}): Promise<R
 		let json: Record<any, any> = {
 			version: 1,
 			moc: options.moc,
-			dfx: options.dfx,
+			replica: options.replica,
+			replicaVersion: options.replicaVersion,
 			gc: options.gc,
 			forceGc: options.forceGc,
 			results: Array.from(results.entries()),

package/commands/install-all.ts

@@ -9,10 +9,10 @@ import {checkIntegrity} from '../integrity.js';
 type InstallAllOptions = {
 	verbose?: boolean;
 	silent?: boolean;
-	lockfile?: 'save' | 'check' | 'ignore';
+	lock?: 'check' | 'update' | 'ignore';
 }
 
-export async function installAll({verbose = false, silent = false, lockfile}: InstallAllOptions = {}) {
+export async function installAll({verbose = false, silent = false, lock}: InstallAllOptions = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -36,12 +36,12 @@ export async function installAll({verbose = false, silent = false, lockfile}: In
 		}
 	}
 
-	if (!silent && lockfile !== 'ignore') {
+	if (!silent && lock !== 'ignore') {
 		logUpdate('Checking integrity...');
 	}
 	await Promise.all([
 		notifyInstalls(Object.keys(installedPackages)),
-		checkIntegrity(lockfile),
+		checkIntegrity(lock),
 	]);
 
 	if (!silent) {

package/commands/remove.ts

@@ -3,17 +3,17 @@ import {deleteSync} from 'del';
 import chalk from 'chalk';
 import {formatDir, formatGithubDir, checkConfigFile, readConfig, writeConfig} from '../mops.js';
 import {Config, Dependency} from '../types.js';
-// import {checkIntegrity} from '../integrity.js';
+import {checkIntegrity} from '../integrity.js';
 
 type RemoveOptions = {
 	verbose?: boolean;
 	dev?: boolean;
 	dryRun?: boolean;
-	lockfile?: 'save' | 'ignore';
+	lock?: 'update' | 'ignore';
 };
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function remove(name: string, {dev = false, verbose = false, dryRun = false, lockfile}: RemoveOptions = {}) {
+export async function remove(name: string, {dev = false, verbose = false, dryRun = false, lock}: RemoveOptions = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -100,7 +100,7 @@ export async function remove(name: string, {dev = false, verbose = false, dryRun
 	}
 	dryRun || writeConfig(config);
 
-	// await checkIntegrity(lockfile);
+	await checkIntegrity(lock);
 
 	console.log(chalk.green('Package removed ') + `${name} = "${version}"`);
 }

package/commands/sync.ts

@@ -8,10 +8,10 @@ import {remove} from './remove.js';
 import {checkIntegrity} from '../integrity.js';
 
 type SyncOptions = {
-	lockfile?: 'save' | 'ignore';
+	lock?: 'update' | 'ignore';
 };
 
-export async function sync({lockfile}: SyncOptions = {}) {
+export async function sync({lock}: SyncOptions = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -28,16 +28,16 @@ export async function sync({lockfile}: SyncOptions = {}) {
 
 	// add missing packages
 	for (let pkg of missing) {
-		await add(pkg, {lockfile: 'ignore'});
+		await add(pkg, {lock: 'ignore'});
 	}
 
 	// remove unused packages
 	for (let pkg of unused) {
 		let dev = devDeps.has(pkg) && !deps.has(pkg);
-		await remove(pkg, {dev, lockfile: 'ignore'});
+		await remove(pkg, {dev, lock: 'ignore'});
 	}
 
-	await checkIntegrity(lockfile);
+	await checkIntegrity(lock);
 }
 
 let ignore = [

package/commands/update.ts

@@ -7,10 +7,10 @@ import {checkIntegrity} from '../integrity.js';
 type UpdateOptions = {
 	verbose?: boolean;
 	dev?: boolean;
-	lockfile?: 'save' | 'ignore';
+	lock?: 'update' | 'ignore';
 };
 
-export async function update(pkg?: string, {lockfile}: UpdateOptions = {}) {
+export async function update(pkg?: string, {lock}: UpdateOptions = {}) {
 	if (!checkConfigFile()) {
 		return;
 	}
@@ -56,5 +56,5 @@ export async function update(pkg?: string, {lockfile}: UpdateOptions = {}) {
 		}
 	}
 
-	await checkIntegrity(lockfile);
+	await checkIntegrity(lock);
 }