@doki-land/nifty 0.1.2 → 0.1.3

package/cli/nifty.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin /env node
+#!/usr/bin/env node
 
 import { createJiti } from "jiti";
 import { dirname, join } from "node:path";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/nifty",
-  "version": "0.1.2",
+  "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.2",
-    "@doki-land/nifty-linux-x64": "0.1.2",
-    "@doki-land/nifty-linux-arm64": "0.1.2",
-    "@doki-land/nifty-darwin-arm64": "0.1.2",
-    "@doki-land/nifty-darwin-x64": "0.1.2"
+    "@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

@@ -44,9 +44,9 @@ export function authPayload(options: AuthCliOptions): {
     npm: string;
 } {
     return {
-        ...(options.otp !== undefined ? { otp: options.otp } : { }),
-        ...(options.totpSecret !== undefined ? { totpSecret: options.totpSecret } : { }),
-        ...(options.token !== undefined ? { token: options.token } : { }),
+        ...(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

@@ -11,10 +11,10 @@ export function registerBumpCommand(cli: Cli): void {
         .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);

package/src/cli/bump.ts

@@ -24,7 +24,7 @@ export type BumpReport = {
 
 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);
@@ -85,27 +85,36 @@ export function bumpWorkspace(options: BumpOptions): BumpReport {
 
     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,
+        cargo: cargoUpdates.map((update) => update.path),
+        npm: npmUpdates.map((update) => update.path),
     };
 }
 
-function readWorkspaceVersion(cargoPaths: string[], npmPaths: string[]): string {
-    const versions = new Set < string> ();
+function readWorkspaceVersion(root: string, cargoPaths: string[], npmPaths: string[]): string {
+    const versions = new Set<string>();
+    let usesWorkspaceVersion = false;
     for (const path of cargoPaths) {
-        versions.add(readCargoVersion(path));
+        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) {
         versions.add(readPackageVersion(path));
@@ -116,20 +125,25 @@ function readWorkspaceVersion(cargoPaths: string[], npmPaths: string[]): string
     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 };
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as { version?: string };
     if (!parsed.version) {
         throw new Error(`no version field in ${path}`);
     }
@@ -165,7 +179,7 @@ export function bumpSemver(version: string, kind: BumpKind): string {
 
 function collectCargoManifests(cratesDir: string): string[] {
     if (!existsSync(cratesDir)) {
-        return[];
+        return [];
     }
     return readdirSync(cratesDir, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
@@ -175,7 +189,7 @@ function collectCargoManifests(cratesDir: string): string[] {
 
 function collectPackageManifests(packagesDir: string): string[] {
     if (!existsSync(packagesDir)) {
-        return[];
+        return [];
     }
     return readdirSync(packagesDir, { withFileTypes: true })
         .filter((entry) => entry.isDirectory() && entry.name !== "node_modules")
@@ -183,33 +197,106 @@ function collectPackageManifests(packagesDir: string): string[] {
         .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 };
+    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}`);
@@ -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.
 `);
 }

package/src/cli/change-logs-cmd.ts

@@ -27,12 +27,12 @@ export function registerChangeLogsCommand(cli: Cli): void {
         .option("--map <path>", "cli.opt.author-map")
         .option("--github-token <token>", "cli.opt.github-token")
         .option("--fetch", "cli.opt.fetch")
-        .action(async(options) => cmdChangeLogsLookup(options));
+        .action(async (options) => cmdChangeLogsLookup(options));
 
-    changeLogs.action(async(options) => cmdChangeLogsRender(options));
+    changeLogs.action(async (options) => cmdChangeLogsRender(options));
 }
 
-export async function cmdChangeLogsRender(options: ParsedOptions): Promise < number> {
+export async function cmdChangeLogsRender(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const cwd = cwdFrom(options) ?? process.cwd();
     const { config } = await loadConfig({ cwd, createIfMissing: false });
@@ -66,7 +66,7 @@ export async function cmdChangeLogsRender(options: ParsedOptions): Promise < num
     return 0;
 }
 
-export async function cmdChangeLogsLookup(options: ParsedOptions): Promise < number> {
+export async function cmdChangeLogsLookup(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const cwd = cwdFrom(options) ?? process.cwd();
     const { config } = await loadConfig({ cwd, createIfMissing: false });
@@ -86,7 +86,7 @@ export async function cmdChangeLogsLookup(options: ParsedOptions): Promise < num
         githubToken: str(options, "github-token") ?? config.githubToken ?? process.env.GITHUB_TOKEN,
         fetch: flag(options, "fetch"),
     });
-    const json: Record < string, unknown > = { };
+    const json: Record<string, unknown> = {};
     if (author.id !== undefined) {
         json.id = author.id;
     }

package/src/cli/cli.ts

@@ -37,7 +37,7 @@ function buildNiftyCli() {
     return cli;
 }
 
-export async function runCli(argv: string[]): Promise < number> {
+export async function runCli(argv: string[]): Promise<number> {
     try {
         return await buildNiftyCli().parse(argv);
     } catch (error) {

package/src/cli/commit-cmd.ts

@@ -17,7 +17,7 @@ export function registerCommitCommand(cli: Cli): void {
         .option("--path <file>", "cli.opt.path")
         .option("--with-lint", "cli.opt.with-lint")
         .option("--errors-only", "cli.opt.errors-only")
-        .action(async(options) => cmdCommitExport(options));
+        .action(async (options) => cmdCommitExport(options));
 
     commit
         .command("apply", "cli.cmd.commit.apply")
@@ -25,7 +25,7 @@ export function registerCommitCommand(cli: Cli): void {
         .option("--ref <ref>", "cli.opt.ref")
         .option("--path <file>", "cli.opt.path")
         .option("--dry-run", "cli.opt.dry-run")
-        .action(async(options) => cmdCommitApply(options));
+        .action(async (options) => cmdCommitApply(options));
 
     commit
         .command("scan", "cli.cmd.commit.scan")
@@ -34,7 +34,7 @@ export function registerCommitCommand(cli: Cli): void {
         .option("-s, --subject <text>...", "cli.opt.subject")
         .option("--json", "cli.opt.json")
         .option("--errors-only", "cli.opt.errors-only")
-        .action(async(options) => cmdCommitScan(options));
+        .action(async (options) => cmdCommitScan(options));
 
     commit
         .command("audit", "cli.cmd.commit.audit")
@@ -43,10 +43,10 @@ export function registerCommitCommand(cli: Cli): void {
         .option("-s, --subject <text>...", "cli.opt.subject")
         .option("--json", "cli.opt.json")
         .option("--errors-only", "cli.opt.errors-only")
-        .action(async(options) => cmdCommitAudit(options));
+        .action(async (options) => cmdCommitAudit(options));
 }
 
-export async function cmdCommitExport(options: ParsedOptions): Promise < number> {
+export async function cmdCommitExport(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const base = requireStr(options, "base");
     const path = str(options, "path") ?? "commit.pending.json";
@@ -77,7 +77,7 @@ export async function cmdCommitExport(options: ParsedOptions): Promise < number>
     return 0;
 }
 
-export async function cmdCommitApply(options: ParsedOptions): Promise < number> {
+export async function cmdCommitApply(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const base = requireStr(options, "base");
     const path = requireStr(options, "path");
@@ -117,13 +117,13 @@ export async function cmdCommitApply(options: ParsedOptions): Promise < number>
     return 0;
 }
 
-export async function cmdCommitScan(options: ParsedOptions): Promise < number> {
+export async function cmdCommitScan(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     await lintCommits({ ...commitLintOptions(options), reportTitle: "commit scan" }, false, true);
     return 0;
 }
 
-export async function cmdCommitAudit(options: ParsedOptions): Promise < number> {
+export async function cmdCommitAudit(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const errorCount = await lintCommits(commitLintOptions(options), false, true);
     return errorCount > 0 ? 1 : 0;
@@ -145,10 +145,10 @@ function commitLintOptions(options: ParsedOptions): LintOptions {
 
 type ExportDocument = {
     version: number;
-    entries: Array < {
+    entries: Array<{
         hash: string;
         message: string;
-        violations?: Array < {
+        violations?: Array<{
             rule: string;
             severity: "error" | "warning" | "info";
             message: string;
@@ -164,7 +164,7 @@ async function lintAndAnnotateExport(options: {
     json: boolean;
     errorsOnly: boolean;
     reportTitle: string;
-}): Promise < number> {
+}): Promise<number> {
     const native = loadNiftyNative();
     const report = native.lint.run({
         cwd: options.cwd,
@@ -173,7 +173,9 @@ async function lintAndAnnotateExport(options: {
         commitOnly: true,
         scanCargo: false,
     });
-    const diagnostics = options.errorsOnly ? report.diagnostics.filter((item) => item.severity === "error") : report.diagnostics;
+    const diagnostics = options.errorsOnly
+        ? report.diagnostics.filter((item) => item.severity === "error")
+        : report.diagnostics;
 
     if (options.json) {
         const { printCommitLintReport } = await import("./commit-lint-report.js");
@@ -190,7 +192,7 @@ async function lintAndAnnotateExport(options: {
         });
     }
 
-    const byHash = new Map < string, Array < { rule: string; severity: "error" | "warning" | "info"; message: string }>>();
+    const byHash = new Map<string, Array<{ rule: string; severity: "error" | "warning" | "info"; message: string }>>();
     for (const item of diagnostics) {
         if (!item.hash) {
             continue;
@@ -201,7 +203,7 @@ async function lintAndAnnotateExport(options: {
     }
 
     const text = await readFile(options.path, "utf8");
-    const document = JSON.parse(text)as ExportDocument;
+    const document = JSON.parse(text) as ExportDocument;
     document.entries = document.entries.map((entry) => {
         const violations = byHash.get(entry.hash);
         if (!violations || violations.length === 0) {

package/src/cli/commit-lint-report.ts

@@ -24,9 +24,11 @@ export function printCommitLintReport(
     diagnostics: CommitLintDiagnostic[],
     errorCount: number,
     warningCount: number,
-    options: CommitLintReportOptions = { },
+    options: CommitLintReportOptions = {},
 ): void {
-    const filtered = options.errorsOnly ? diagnostics.filter((item) => item.severity === "error") : diagnostics;
+    const filtered = options.errorsOnly
+        ? diagnostics.filter((item) => item.severity === "error")
+        : diagnostics;
 
     if (options.json) {
         const payload = {
@@ -57,7 +59,7 @@ export function printCommitLintReport(
     const summary = summarizeByRule(filtered.filter((item) => item.severity === "error"));
     if (summary.length > 0) {
         console.log("summary by rule:");
-        for (const[rule, count]of summary) {
+        for (const [rule, count] of summary) {
             console.log(`  ${rule}  ${count}`);
         }
         console.log();
@@ -65,7 +67,7 @@ export function printCommitLintReport(
 }
 
 function groupCommitDiagnostics(diagnostics: CommitLintDiagnostic[]): CommitLintGroup[] {
-    const groups = new Map < string, CommitLintGroup > ();
+    const groups = new Map<string, CommitLintGroup>();
     const order: string[] = [];
 
     for (const item of diagnostics) {
@@ -84,12 +86,12 @@ function groupCommitDiagnostics(diagnostics: CommitLintDiagnostic[]): CommitLint
     return order.map((key) => groups.get(key)!);
 }
 
-function summarizeByRule(diagnostics: CommitLintDiagnostic[]): Array < [string, number] > {
-    const counts = new Map < string, number > ();
+function summarizeByRule(diagnostics: CommitLintDiagnostic[]): Array<[string, number]> {
+    const counts = new Map<string, number>();
     for (const item of diagnostics) {
         counts.set(item.rule, (counts.get(item.rule) ?? 0) + 1);
     }
-    return[...counts.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    return [...counts.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
 }
 
 function printCommitGroup(group: CommitLintGroup): void {

package/src/cli/context.ts

@@ -23,13 +23,13 @@ export function parseCliContext(argv: string[]): { cwd: string; dryRun: boolean
 }
 
 /** Ensure `nifty.config.*` exists before running a command (skip create on `--dry-run`). */
-export async function bootstrapNiftyConfig(argv: string[]): Promise < void> {
+export async function bootstrapNiftyConfig(argv: string[]): Promise<void> {
     const { cwd, dryRun } = parseCliContext(argv);
     await loadConfig({ cwd, createIfMissing: !dryRun });
 }
 
 /** Commander action hook: load config from parsed global/command flags. */
-export async function bootstrapFromOptions(options: ParsedOptions): Promise < void> {
+export async function bootstrapFromOptions(options: ParsedOptions): Promise<void> {
     const cwd = cwdFrom(options) ?? process.cwd();
     const dryRun = options["dry-run"] === true;
     await loadConfig({ cwd, createIfMissing: !dryRun });

package/src/cli/format-cmd.ts

@@ -7,10 +7,10 @@ import { cwdFrom, flag } from "./options.js";
 export function registerFormatCommand(cli: Cli): void {
     cli.command("format", "cli.cmd.format")
         .option("--check", "cli.opt.check")
-        .action(async(options) => cmdFormat(options));
+        .action(async (options) => cmdFormat(options));
 }
 
-export async function cmdFormat(options: ParsedOptions): Promise < number> {
+export async function cmdFormat(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
     const exitCode = await formatWorkspace({
         check: flag(options, "check"),

package/src/cli/format.ts

@@ -6,7 +6,7 @@ export type FormatOptions = {
     cwd?: string;
 };
 
-export async function formatWorkspace(options: FormatOptions): Promise < number> {
+export async function formatWorkspace(options: FormatOptions): Promise<number> {
     const cwd = options.cwd ?? process.cwd();
     const { config } = await loadConfig({ cwd, createIfMissing: false, env: { command: "format" } });
     const resolved = resolveFormatConfig(config.format);

package/src/cli/install-native-cmd.ts

@@ -6,10 +6,10 @@ import { cwdFrom, str } from "./options.js";
 export function registerInstallNativeCommand(cli: Cli): void {
     cli.command("install-native", "cli.cmd.install-native")
         .option("--from <dir>", "cli.opt.from-artifacts")
-        .action(async(options) => cmdInstallNative(options));
+        .action(async (options) => cmdInstallNative(options));
 }
 
-export async function cmdInstallNative(options: ParsedOptions): Promise < number> {
+export async function cmdInstallNative(options: ParsedOptions): Promise<number> {
     const from =
         str(options, "from") ??
         process.env.NATIVE_ARTIFACT_ROOT ??

package/src/cli/install-native.ts

@@ -4,7 +4,7 @@ import { basename, dirname, join, relative, resolve } from "node:path";
 import { detectProjectLayout } from "../config/detectProject.js";
 
 /** Basename of a built .node file → platform package directory under projects/packages/. */
-const PACKAGE_BY_ASSET: Record < string, string > = {
+const PACKAGE_BY_ASSET: Record<string, string> = {
     "nifty-win32-x64-msvc.node": "nifty-win32-x64",
     "nifty-linux-x64-gnu.node": "nifty-linux-x64",
     "nifty-linux-arm64-gnu.node": "nifty-linux-arm64",

package/src/cli/lint-cmd.ts

@@ -15,10 +15,10 @@ function registerLintLike(cli: Cli, name: string, helpId: string, check: boolean
         .option("--to <ref>", "cli.opt.to")
         .option("-s, --subject <text>...", "cli.opt.subject")
         .option("--no-cargo", "cli.opt.no-cargo")
-        .action(async(options) => cmdLint(options, check));
+        .action(async (options) => cmdLint(options, check));
 }
 
-export async function cmdLint(options: ParsedOptions, check: boolean): Promise < number> {
+export async function cmdLint(options: ParsedOptions, check: boolean): Promise<number> {
     await bootstrapFromOptions(options);
     const lintOptions: LintOptions = {
         subjects: strList(options, "subject"),

package/src/cli/lint.ts

@@ -22,7 +22,7 @@ type LintRuleConfig = {
     severity?: "error" | "warning" | "info";
 };
 
-export async function runLint(argv: string[], check: boolean): Promise < void> {
+export async function runLint(argv: string[], check: boolean): Promise<void> {
     const options = parseLintArgs(argv);
     const errorCount = await lintCommits(options, check);
     if (check && errorCount > 0) {
@@ -34,7 +34,7 @@ export async function lintCommits(
     options: LintOptions,
     check: boolean,
     commitOnly = options.commitOnly ?? false,
-): Promise < number> {
+): Promise<number> {
     const native = loadNiftyNative();
     const cwd = options.cwd ?? process.cwd();
     const { config } = await loadConfig({ cwd, createIfMissing: false });
@@ -84,7 +84,11 @@ function printWorkspaceDiagnostic(item: LintDiagnostic): void {
         return;
     }
     const location =
-        item.path !== undefined ? item.line !== undefined ? `${item.path}:${item.line}` : item.path : undefined;
+        item.path !== undefined
+            ? item.line !== undefined
+                ? `${item.path}:${item.line}`
+                : item.path
+            : undefined;
     const suffix = location ? ` @ ${location}` : "";
     console.log(`${prefix} [${item.rule}] ${item.message}${suffix}`);
 }

package/src/cli/options.ts

@@ -25,9 +25,9 @@ export function strList(options: ParsedOptions, key: string): string[] {
         return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
     }
     if (typeof value === "string" && value.length > 0) {
-        return[value];
+        return [value];
     }
-    return[];
+    return [];
 }
 
 export function authFromOptions(options: ParsedOptions): AuthCliOptions {