@doki-land/nifty 0.1.1 → 0.1.2

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.2",
   "description": "Gitmoji-first commit conventions and release helpers (Node-API + TypeScript)",
   "type": "module",
   "license": "MPL-2.0",
@@ -24,11 +24,11 @@
     "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.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"
   },
   "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,23 +62,23 @@ 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");
@@ -89,71 +89,71 @@ export function bumpWorkspace(options : BumpOptions) : BumpReport {
     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 cargo = cargoPaths.map((path) => bumpCargoManifest(path, to, options.dryRun));
+    const npm = npmPaths.map((path) => bumpPackageManifest(path, to, options.dryRun));
 
     return {
         root,
         from,
         to,
-        kind : options.version ? undefined : options.kind ?? DEFAULT_KIND,
+        kind: options.version ? undefined : options.kind ?? DEFAULT_KIND,
         cargo,
         npm,
     };
 }
 
-function readWorkspaceVersion(cargoPaths : string[], npmPaths : string[]) : string {
-    const versions = new Set<string>();
-    for(const path of cargoPaths){
+function readWorkspaceVersion(cargoPaths: string[], npmPaths: string[]): string {
+    const versions = new Set < string> ();
+    for (const path of cargoPaths) {
         versions.add(readCargoVersion(path));
     }
-    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];
 }
 
-function readCargoVersion(path : string) : string {
+function readCargoVersion(path: string): string {
     const original = readFileSync(path, "utf8");
-    const match = original.match( /^version\s*=\s*"([^"]*)"/m);
-    if(!match){
+    const match = original.match(/^version\s*=\s*"([^"]*)"/m);
+    if (!match) {
         throw new Error(`no [package].version found in ${path}`);
     }
     return match[1];
 }
 
-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 +163,65 @@ export function bumpSemver(version : string, kind : BumpKind) : string {
     return `${major}.${minor}.${patch}`;
 }
 
-function collectCargoManifests(cratesDir : string) : string[]{
-    if(!existsSync(cratesDir)){
+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)){
+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 {
+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){
+    const next = original.replace(/^version\s*=\s*"[^"]*"/m, `version = "${version}"`);
+    if (next === original) {
         throw new Error(`no [package].version found in ${path}`);
     }
-    if(!dryRun){
+    if (!dryRun) {
         writeFileSync(path, next, "utf8");
     }
     return path;
 }
 
-function bumpPackageManifest(path : string, version : string, dryRun ? : boolean) : string {
+function bumpPackageManifest(path: string, version: string, dryRun?: boolean) : string {
     const original = readFileSync(path, "utf8");
-    const parsed = JSON.parse(original)as { version ? : string };
-    if(!parsed.version){
+    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){
+    if (!dryRun) {
         writeFileSync(path, next, "utf8");
     }
     return path;
 }
 
-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:

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

@@ -9,7 +9,7 @@ import { loadNiftyNative } from "../native.js";
 import { bootstrapFromOptions } from "./context.js";
 import { cwdFrom, flag, str } from "./options.js";
 
-export function registerChangeLogsCommand(cli : Cli) : void {
+export function registerChangeLogsCommand(cli: Cli): void {
     const changeLogs = cli.command("change-logs", "cli.cmd.change-logs")
         .option("--version <version>", "cli.opt.version")
         .option("--from <ref>", "cli.opt.from")
@@ -27,54 +27,54 @@ 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 });
+    const { config } = await loadConfig({ cwd, createIfMissing: false });
     const layout = detectProjectLayout(cwd);
     const repoRoot = config.repoRoot ?? layout.root;
     const native = loadNiftyNative();
     const report = native.history["changelog-render"]({
         cwd,
-        version : str(options, "version"),
-        fromRef : str(options, "from"),
-        toRef : str(options, "to"),
-        write : flag(options, "write"),
-        tags : flag(options, "tags"),
-        repo : str(options, "repo") ?? config.changelog ?.repo,
-        authorMap : str(options, "author-map") ?? resolveAuthorMapPath(config, repoRoot),
-        releasesDir : str(options, "releases-dir") ?? config.changelog ?.releasesDir,
+        version: str(options, "version"),
+        fromRef: str(options, "from"),
+        toRef: str(options, "to"),
+        write: flag(options, "write"),
+        tags: flag(options, "tags"),
+        repo: str(options, "repo") ?? config.changelog?.repo,
+        authorMap: str(options, "author-map") ?? resolveAuthorMapPath(config, repoRoot),
+        releasesDir: str(options, "releases-dir") ?? config.changelog?.releasesDir,
     });
 
-    if(flag(options, "tags")){
+    if (flag(options, "tags")) {
         console.log(report.notes);
         return 0;
     }
 
-    if(report.rangeLabel){
+    if (report.rangeLabel) {
         console.error(`change-logs: ${report.rangeLabel} — ${report.commitCount} commit(s)`);
     }
-    if(report.writtenPath){
+    if (report.writtenPath) {
         console.error(`change-logs: wrote ${report.writtenPath}`);
     }
     process.stdout.write(report.notes);
     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 });
+    const { config } = await loadConfig({ cwd, createIfMissing: false });
     const layout = detectProjectLayout(cwd);
     const repoRoot = config.repoRoot ?? layout.root;
     const email = str(options, "email");
     const login = str(options, "login");
-    if(!email && !login){
+    if (!email && !login) {
         throw new Error("lookup requires --email or --login");
     }
     const native = loadNiftyNative();
@@ -82,15 +82,15 @@ export async function cmdChangeLogsLookup(options : ParsedOptions) : Promise<num
         cwd,
         email,
         login,
-        map : str(options, "map") ?? resolveAuthorMapPath(config, repoRoot),
-        githubToken : str(options, "github-token") ?? config.githubToken ?? process.env.GITHUB_TOKEN,
-        fetch : flag(options, "fetch"),
+        map: str(options, "map") ?? resolveAuthorMapPath(config, repoRoot),
+        githubToken: str(options, "github-token") ?? config.githubToken ?? process.env.GITHUB_TOKEN,
+        fetch: flag(options, "fetch"),
     });
-    const json : Record<string, unknown> = { };
-    if(author.id!== undefined){
+    const json: Record < string, unknown > = { };
+    if (author.id !== undefined) {
         json.id = author.id;
     }
-    if(author.login){
+    if (author.login) {
         json.login = author.login;
     }
     console.log(JSON.stringify(json, null, 2));
@@ -98,6 +98,6 @@ export async function cmdChangeLogsLookup(options : ParsedOptions) : Promise<num
 }
 
 /** Default author map path relative to repo root (matches git-change-logs). */
-export function defaultAuthorMapPath(repoRoot : string) : string {
+export function defaultAuthorMapPath(repoRoot: string): string {
     return join(repoRoot, "documentation/maintenance/author-github.json");
 }

package/src/cli/cli.ts

@@ -15,7 +15,7 @@ import { registerTrustCommand } from "./trust-cmd.js";
 import { registerUpdateCommand } from "./update-cmd.js";
 import { registerUploadCommand } from "./upload-cmd.js";
 
-function buildNiftyCli(){
+function buildNiftyCli() {
     const localesRoot = join(dirname(fileURLToPath(import.meta.url)), "../../locales");
     const cli = createCli("nifty")
         .locales(localesRoot)
@@ -37,10 +37,10 @@ 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){
+    } catch (error) {
         console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
         return 1;
     }