@doki-land/nifty 0.1.1 → 0.1.3

package/cli/nifty.mjs

@@ -1,11 +1,11 @@
-#! /usr/bin /env node
+#!/usr/bin/env node
 
 import { createJiti } from "jiti";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const here = dirname(fileURLToPath(import.meta.url));
-const jiti = createJiti(import.meta.url, { interopDefault : true });
+const jiti = createJiti(import.meta.url, { interopDefault: true });
 const { runCli } = await jiti.import(join(here, "../src/cli/main.ts"));
 
 process.exit(await runCli(process.argv.slice(2)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/nifty",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Gitmoji-first commit conventions and release helpers (Node-API + TypeScript)",
   "type": "module",
   "license": "MPL-2.0",
@@ -17,18 +17,19 @@
     "src"
   ],
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "node --test tests/*.test.mjs"
   },
   "dependencies": {
     "@vmz/commander": "^0.2.0",
     "jiti": "^2.4.2"
   },
   "optionalDependencies": {
-    "@doki-land/nifty-win32-x64": "0.1.1",
-    "@doki-land/nifty-linux-x64": "0.1.1",
-    "@doki-land/nifty-linux-arm64": "0.1.1",
-    "@doki-land/nifty-darwin-arm64": "0.1.1",
-    "@doki-land/nifty-darwin-x64": "0.1.1"
+    "@doki-land/nifty-win32-x64": "0.1.3",
+    "@doki-land/nifty-linux-x64": "0.1.3",
+    "@doki-land/nifty-linux-arm64": "0.1.3",
+    "@doki-land/nifty-darwin-arm64": "0.1.3",
+    "@doki-land/nifty-darwin-x64": "0.1.3"
   },
   "publishConfig": {
     "access": "public"

package/src/cli/authArgs.ts

@@ -1,30 +1,30 @@
 import { resolveNpmExecutable } from "./resolveNpm.js";
 
 export type AuthCliOptions = {
-    otp ? : string;
-    totpSecret ? : string;
-    token ? : string;
-    npm : string;
+    otp?: string;
+    totpSecret?: string;
+    token?: string;
+    npm: string;
 };
 
-export function parseAuthArgs(argv : string[]) : AuthCliOptions {
-    let otp : string | undefined;
-    let totpSecret : string | undefined;
-    let token : string | undefined;
+export function parseAuthArgs(argv: string[]): AuthCliOptions {
+    let otp: string | undefined;
+    let totpSecret: string | undefined;
+    let token: string | undefined;
 
-    for(let i = 0; i<argv.length; i += 1){
+    for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if(arg === "--otp"){
-            otp = argv[ ++ i];
-        } else if(arg === "--totp-secret"){
-            totpSecret = argv[ ++ i];
-        } else if(arg === "--token"){
-            token = argv[ ++ i];
-        } else if(arg.startsWith("--otp=")){
+        if (arg === "--otp") {
+            otp = argv[++i];
+        } else if (arg === "--totp-secret") {
+            totpSecret = argv[++i];
+        } else if (arg === "--token") {
+            token = argv[++i];
+        } else if (arg.startsWith("--otp=")) {
             otp = arg.slice("--otp=".length);
-        } else if(arg.startsWith("--totp-secret=")){
+        } else if (arg.startsWith("--totp-secret=")) {
             totpSecret = arg.slice("--totp-secret=".length);
-        } else if(arg.startsWith("--token=")){
+        } else if (arg.startsWith("--token=")) {
             token = arg.slice("--token=".length);
         }
     }
@@ -33,20 +33,20 @@ export function parseAuthArgs(argv : string[]) : AuthCliOptions {
         otp,
         totpSecret,
         token,
-        npm : resolveNpmExecutable(),
+        npm: resolveNpmExecutable(),
     };
 }
 
-export function authPayload(options : AuthCliOptions) : {
-    otp ? : string;
-    totpSecret ? : string;
-    token ? : string;
-    npm : string;
-}{
+export function authPayload(options: AuthCliOptions): {
+    otp?: string;
+    totpSecret?: string;
+    token?: string;
+    npm: string;
+} {
     return {
-        ...(options.otp!== undefined ? { otp : options.otp } : { }),
-        ...(options.totpSecret!== undefined ? { totpSecret : options.totpSecret } : { }),
-        ...(options.token!== undefined ? { token : options.token } : { }),
-        npm : options.npm,
+        ...(options.otp !== undefined ? { otp: options.otp } : {}),
+        ...(options.totpSecret !== undefined ? { totpSecret: options.totpSecret } : {}),
+        ...(options.token !== undefined ? { token: options.token } : {}),
+        npm: options.npm,
     };
 }

package/src/cli/bump-cmd.ts

@@ -4,17 +4,17 @@ import { bumpWorkspace, printBumpReport, type BumpKind, type BumpOptions } from
 import { bootstrapFromOptions } from "./context.js";
 import { cwdFrom, flag, str } from "./options.js";
 
-export function registerBumpCommand(cli : Cli) : void {
+export function registerBumpCommand(cli: Cli): void {
     cli.command("bump", "cli.cmd.bump")
         .option("--dry-run", "cli.opt.dry-run")
         .option("--version, -v <version>", "cli.opt.version")
         .option("--patch", "cli.opt.patch")
         .option("--minor", "cli.opt.minor")
         .option("--major", "cli.opt.major")
-        .action(async(options) =>cmdBump(options));
+        .action(async (options) => cmdBump(options));
 }
 
-export async function cmdBump(options : ParsedOptions) : Promise<number>{
+export async function cmdBump(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const bumpOptions = bumpOptionsFromParsed(options);
     const report = bumpWorkspace(bumpOptions);
@@ -22,34 +22,34 @@ export async function cmdBump(options : ParsedOptions) : Promise<number>{
     return 0;
 }
 
-function bumpOptionsFromParsed(options : ParsedOptions) : BumpOptions {
+function bumpOptionsFromParsed(options: ParsedOptions): BumpOptions {
     let version = str(options, "version");
-    let kind : BumpKind = "patch";
-    if(flag(options, "major")){
+    let kind: BumpKind = "patch";
+    if (flag(options, "major")) {
         kind = "major";
-    } else if(flag(options, "minor")){
+    } else if (flag(options, "minor")) {
         kind = "minor";
-    } else if(flag(options, "patch")){
+    } else if (flag(options, "patch")) {
         kind = "patch";
     }
-    for(const positional of options._){
-        if(isBumpKind(positional)){
+    for (const positional of options._) {
+        if (isBumpKind(positional)) {
             kind = positional;
-        } else if(positional){
+        } else if (positional) {
             version = positional;
         }
     }
-    if(version && ! /^\d+\.\d+\.\d+(-[\w.-]+)?$/ .test(version)){
+    if (version && !/^\d+\.\d+\.\d+(-[\w.-]+)?$/.test(version)) {
         throw new Error(`invalid version ${version}, expected semver like 0.0.0`);
     }
     return {
         version,
         kind,
-        cwd : cwdFrom(options),
-        dryRun : flag(options, "dry-run"),
+        cwd: cwdFrom(options),
+        dryRun: flag(options, "dry-run"),
     };
 }
 
-function isBumpKind(value : string) : value is BumpKind {
+function isBumpKind(value: string): value is BumpKind {
     return value === "patch" || value === "minor" || value === "major";
 }

package/src/cli/bump.ts

@@ -7,54 +7,54 @@ export type BumpKind = "patch" | "minor" | "major";
 
 export type BumpOptions = {
     /** Explicit target version. When set, overrides `kind`. */
-    version ? : string;
-    kind ? : BumpKind;
-    cwd ? : string;
-    dryRun ? : boolean;
+    version?: string;
+    kind?: BumpKind;
+    cwd?: string;
+    dryRun?: boolean;
 };
 
 export type BumpReport = {
-    root : string;
-    from : string;
-    to : string;
-    kind ? : BumpKind;
-    cargo : string[];
-    npm : string[];
+    root: string;
+    from: string;
+    to: string;
+    kind?: BumpKind;
+    cargo: string[];
+    npm: string[];
 };
 
-const DEFAULT_KIND : BumpKind = "patch";
+const DEFAULT_KIND: BumpKind = "patch";
 
-export async function runBump(argv : string[]) : Promise<void>{
+export async function runBump(argv: string[]): Promise<void> {
     const options = parseBumpArgs(argv);
     const report = bumpWorkspace(options);
     printBumpReport(report, options.dryRun);
 }
 
-function parseBumpArgs(argv : string[]) : BumpOptions {
-    let version : string | undefined;
-    let kind : BumpKind = DEFAULT_KIND;
-    let cwd : string | undefined;
+function parseBumpArgs(argv: string[]): BumpOptions {
+    let version: string | undefined;
+    let kind: BumpKind = DEFAULT_KIND;
+    let cwd: string | undefined;
     let dryRun = false;
 
-    for(let i = 0; i<argv.length; i += 1){
+    for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
-        if(arg === "--dry-run"){
+        if (arg === "--dry-run") {
             dryRun = true;
-        } else if(arg === "-C" || arg === "--cwd"){
-            cwd = argv[ ++ i];
-        } else if(arg === "--version" || arg === "-v"){
-            version = argv[ ++ i];
-        } else if(arg === "--patch"){
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = argv[++i];
+        } else if (arg === "--version" || arg === "-v") {
+            version = argv[++i];
+        } else if (arg === "--patch") {
             kind = "patch";
-        } else if(arg === "--minor"){
+        } else if (arg === "--minor") {
             kind = "minor";
-        } else if(arg === "--major"){
+        } else if (arg === "--major") {
             kind = "major";
-        } else if(arg === "-h" || arg === "--help"){
+        } else if (arg === "-h" || arg === "--help") {
             printBumpHelp();
             process.exit(0);
-        } else if(!arg.startsWith("-")){
-            if(isBumpKind(arg)){
+        } else if (!arg.startsWith("-")) {
+            if (isBumpKind(arg)) {
                 kind = arg;
             } else {
                 version = arg;
@@ -62,98 +62,112 @@ function parseBumpArgs(argv : string[]) : BumpOptions {
         }
     }
 
-    if(version){
+    if (version) {
         assertVersion(version);
     }
     return { version, kind, cwd, dryRun };
 }
 
-function isBumpKind(value : string) : value is BumpKind {
+function isBumpKind(value: string): value is BumpKind {
     return value === "patch" || value === "minor" || value === "major";
 }
 
-function assertVersion(version : string) : void {
-    if(! /^\d+\.\d+\.\d+(-[\w.-]+)?$/ .test(version)){
+function assertVersion(version: string): void {
+    if (!/^\d+\.\d+\.\d+(-[\w.-]+)?$/.test(version)) {
         throw new Error(`invalid version ${version}, expected semver like 0.0.0`);
     }
 }
 
-export function bumpWorkspace(options : BumpOptions) : BumpReport {
+export function bumpWorkspace(options: BumpOptions): BumpReport {
     const root = findWorkspaceRoot(options.cwd ?? process.cwd());
     const cratesDir = join(root, "projects", "crates");
     const packagesDir = join(root, "projects", "packages");
 
     const cargoPaths = collectCargoManifests(cratesDir);
     const npmPaths = collectPackageManifests(packagesDir);
-    const from = readWorkspaceVersion(cargoPaths, npmPaths);
+    const from = readWorkspaceVersion(root, cargoPaths, npmPaths);
     const to = options.version ?? bumpSemver(from, options.kind ?? DEFAULT_KIND);
     assertVersion(to);
 
-    const cargo = cargoPaths.map((path) =>bumpCargoManifest(path, to, options.dryRun));
-    const npm = npmPaths.map((path) =>bumpPackageManifest(path, to, options.dryRun));
+    const cargoUpdates = prepareCargoUpdates(root, cargoPaths, to);
+    const npmUpdates = npmPaths.map((path) => preparePackageUpdate(path, to));
+    if (!options.dryRun) {
+        cargoUpdates.concat(npmUpdates).forEach((update) => writeFileSync(update.path, update.next, "utf8"));
+    }
 
     return {
         root,
         from,
         to,
-        kind : options.version ? undefined : options.kind ?? DEFAULT_KIND,
-        cargo,
-        npm,
+        kind: options.version ? undefined : options.kind ?? DEFAULT_KIND,
+        cargo: cargoUpdates.map((update) => update.path),
+        npm: npmUpdates.map((update) => update.path),
     };
 }
 
-function readWorkspaceVersion(cargoPaths : string[], npmPaths : string[]) : string {
+function readWorkspaceVersion(root: string, cargoPaths: string[], npmPaths: string[]): string {
     const versions = new Set<string>();
-    for(const path of cargoPaths){
-        versions.add(readCargoVersion(path));
+    let usesWorkspaceVersion = false;
+    for (const path of cargoPaths) {
+        const info = readCargoVersion(path);
+        if (info.inherited) usesWorkspaceVersion = true;
+        else versions.add(info.version);
+    }
+    if (usesWorkspaceVersion) {
+        versions.add(readWorkspacePackageVersion(join(root, "Cargo.toml")).version);
     }
-    for(const path of npmPaths){
+    for (const path of npmPaths) {
         versions.add(readPackageVersion(path));
     }
-    if(versions.size === 0){
+    if (versions.size === 0) {
         throw new Error("no crate or package versions found in workspace");
     }
-    if(versions.size>1){
+    if (versions.size > 1) {
         throw new Error(`workspace versions are out of sync: ${[...versions].sort().join(", ")}`);
     }
-    return[...versions][0];
+    return [...versions][0];
 }
 
-function readCargoVersion(path : string) : string {
+type CargoVersion = { version: string; inherited: boolean };
+
+type FileUpdate = { path: string; next: string };
+
+function readCargoVersion(path: string): CargoVersion {
     const original = readFileSync(path, "utf8");
-    const match = original.match( /^version\s*=\s*"([^"]*)"/m);
-    if(!match){
-        throw new Error(`no [package].version found in ${path}`);
+    const field = findTomlField(original, "package", "version.workspace") ?? findTomlField(original, "package", "version");
+    if (!field) throw new Error(`no [package].version found in ${path}`);
+    if (isWorkspaceInheritedVersion(field)) {
+        return { version: "", inherited: true };
     }
-    return match[1];
+    return { version: parseTomlString(field.value, `[package].version in ${path}`), inherited: false };
 }
 
-function readPackageVersion(path : string) : string {
-    const parsed = JSON.parse(readFileSync(path, "utf8"))as { version ? : string };
-    if(!parsed.version){
+function readPackageVersion(path: string): string {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as { version?: string };
+    if (!parsed.version) {
         throw new Error(`no version field in ${path}`);
     }
     return parsed.version;
 }
 
-export function bumpSemver(version : string, kind : BumpKind) : string {
-    const match = version.match( /^(\d+)\.(\d+)\.(\d+)(?:-.*)?$/ );
-    if(!match){
+export function bumpSemver(version: string, kind: BumpKind): string {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-.*)?$/);
+    if (!match) {
         throw new Error(`cannot bump non-semver version ${version}`);
     }
     let major = Number(match[1]);
     let minor = Number(match[2]);
     let patch = Number(match[3]);
 
-    switch(kind){
-        case "patch" :
+    switch (kind) {
+        case "patch":
             patch += 1;
             break;
-        case "minor" :
+        case "minor":
             minor += 1;
             patch = 0;
             break;
-        case "major" :
+        case "major":
             major += 1;
             minor = 0;
             patch = 0;
@@ -163,65 +177,138 @@ export function bumpSemver(version : string, kind : BumpKind) : string {
     return `${major}.${minor}.${patch}`;
 }
 
-function collectCargoManifests(cratesDir : string) : string[]{
-    if(!existsSync(cratesDir)){
-        return[];
+function collectCargoManifests(cratesDir: string): string[] {
+    if (!existsSync(cratesDir)) {
+        return [];
     }
-    return readdirSync(cratesDir, { withFileTypes : true })
-        .filter((entry) =>entry.isDirectory())
-        .map((entry) =>join(cratesDir, entry.name, "Cargo.toml"))
-        .filter((path) =>existsSync(path));
+    return readdirSync(cratesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => join(cratesDir, entry.name, "Cargo.toml"))
+        .filter((path) => existsSync(path));
 }
 
-function collectPackageManifests(packagesDir : string) : string[]{
-    if(!existsSync(packagesDir)){
-        return[];
+function collectPackageManifests(packagesDir: string): string[] {
+    if (!existsSync(packagesDir)) {
+        return [];
     }
-    return readdirSync(packagesDir, { withFileTypes : true })
-        .filter((entry) =>entry.isDirectory() && entry.name!== "node_modules")
-        .map((entry) =>join(packagesDir, entry.name, "package.json"))
-        .filter((path) =>existsSync(path));
+    return readdirSync(packagesDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name !== "node_modules")
+        .map((entry) => join(packagesDir, entry.name, "package.json"))
+        .filter((path) => existsSync(path));
 }
 
-function bumpCargoManifest(path : string, version : string, dryRun ? : boolean) : string {
-    const original = readFileSync(path, "utf8");
-    const next = original.replace( /^version\s*=\s*"[^"]*"/m, `version = "${version}"`);
-    if(next === original){
-        throw new Error(`no [package].version found in ${path}`);
+function prepareCargoUpdates(root: string, cargoPaths: string[], version: string): FileUpdate[] {
+    const updates: FileUpdate[] = [];
+    let usesWorkspaceVersion = false;
+    for (const path of cargoPaths) {
+        const original = readFileSync(path, "utf8");
+        const field = findTomlField(original, "package", "version.workspace") ?? findTomlField(original, "package", "version");
+        if (!field) throw new Error(`no [package].version found in ${path}`);
+        if (isWorkspaceInheritedVersion(field)) {
+            usesWorkspaceVersion = true;
+            continue;
+        }
+        parseTomlString(field.value, `[package].version in ${path}`);
+        updates.push({ path, next: replaceTomlField(original, field, version) });
     }
-    if(!dryRun){
-        writeFileSync(path, next, "utf8");
+    if (usesWorkspaceVersion) {
+        const path = join(root, "Cargo.toml");
+        const original = readFileSync(path, "utf8");
+        const field = findTomlField(original, "workspace.package", "version");
+        if (!field) {
+            throw new Error(`Cargo members inherit version.workspace but ${path} has no [workspace.package].version`);
+        }
+        parseTomlString(field.value, `[workspace.package].version in ${path}`);
+        updates.push({ path, next: replaceTomlField(original, field, version) });
     }
-    return path;
+    return updates;
 }
 
-function bumpPackageManifest(path : string, version : string, dryRun ? : boolean) : string {
+function readWorkspacePackageVersion(path: string): CargoVersion {
     const original = readFileSync(path, "utf8");
-    const parsed = JSON.parse(original)as { version ? : string };
-    if(!parsed.version){
+    const field = findTomlField(original, "workspace.package", "version");
+    if (!field) throw new Error(`Cargo members inherit version.workspace but ${path} has no [workspace.package].version`);
+    return { version: parseTomlString(field.value, `[workspace.package].version in ${path}`), inherited: false };
+}
+
+function isWorkspaceInheritedVersion(field: NonNullable<ReturnType<typeof findTomlField>>): boolean {
+    if (field.key === "version.workspace") return true;
+    const value = field.value.trim();
+    if (!value.startsWith("{") || !value.endsWith("}")) return false;
+    return value
+        .slice(1, -1)
+        .split(",")
+        .some((assignment) => {
+            const equals = assignment.indexOf("=");
+            return equals >= 0 && assignment.slice(0, equals).trim() === "workspace" && assignment.slice(equals + 1).trim() === "true";
+        });
+}
+
+function findTomlField(contents: string, table: string, name: string) {
+    let currentTable = "";
+    const lines = contents.split(/(?<=\n)/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        const tableMatch = trimmed.match(/^\[([^\]]+)\]$/);
+        if (tableMatch) {
+            currentTable = tableMatch[1].trim();
+            continue;
+        }
+        if (trimmed.startsWith("[[")) {
+            currentTable = "";
+            continue;
+        }
+        if (currentTable !== table) continue;
+        const fieldMatch = line.match(new RegExp(`^(\\s*)(${name.replace(".", "\\.")})\\s*=\\s*(.*?)(\\r?\\n?)$`));
+        if (fieldMatch) return { index, line, indent: fieldMatch[1], key: fieldMatch[2], value: fieldMatch[3], ending: fieldMatch[4] };
+    }
+    return undefined;
+}
+
+function parseTomlString(value: string, description: string): string {
+    const trimmed = value.trim();
+    const quote = trimmed[0];
+    if (quote !== '"' && quote !== "'") throw new Error(`expected a quoted string for ${description}`);
+    const closingQuote = trimmed.indexOf(quote, 1);
+    if (closingQuote < 0) throw new Error(`expected a quoted string for ${description}`);
+    const trailing = trimmed.slice(closingQuote + 1).trim();
+    if (trailing && !trailing.startsWith("#")) throw new Error(`expected a quoted string for ${description}`);
+    return trimmed.slice(1, closingQuote);
+}
+
+function replaceTomlField(contents: string, field: NonNullable<ReturnType<typeof findTomlField>>, version: string): string {
+    const value = field.value.trimStart();
+    const closingQuote = value.indexOf(value[0], 1);
+    const suffix = closingQuote >= 0 ? value.slice(closingQuote + 1) : "";
+    const line = `${field.indent}${field.key} = "${version}"${suffix}${field.ending}`;
+    return contents.split(/(?<=\n)/).map((current, index) => index === field.index ? line : current).join("");
+}
+
+function preparePackageUpdate(path: string, version: string): FileUpdate {
+    const original = readFileSync(path, "utf8");
+    const parsed = JSON.parse(original) as { version?: string };
+    if (!parsed.version) {
         throw new Error(`no version field in ${path}`);
     }
     parsed.version = version;
     const next = `${JSON.stringify(parsed, null, 4)}\n`;
-    if(!dryRun){
-        writeFileSync(path, next, "utf8");
-    }
-    return path;
+    return { path, next };
 }
 
-export function printBumpReport(report : BumpReport, dryRun ? : boolean) : void {
+export function printBumpReport(report: BumpReport, dryRun?: boolean): void {
     const prefix = dryRun ? "would bump" : "bumped";
     const kind = report.kind ? ` (${report.kind})` : "";
     console.log(`${prefix} workspace ${report.root} ${report.from} -> ${report.to}${kind}`);
-    for(const path of report.cargo){
+    for (const path of report.cargo) {
         console.log(`  cargo: ${path}`);
     }
-    for(const path of report.npm){
+    for (const path of report.npm) {
         console.log(`  npm: ${path}`);
     }
 }
 
-function printBumpHelp() : void {
+function printBumpHelp(): void {
     console.log(`nifty bump — align all crate and package versions in the workspace
 
 Usage:
@@ -233,5 +320,7 @@ Usage:
   nifty bump --version 1.2.3
   nifty bump --dry-run
   nifty bump -C <cwd>
+
+Cargo members using version.workspace = true are updated through the root [workspace.package].version.
 `);
 }