@doki-land/nifty 0.0.0 → 0.0.2

package/src/cli/context.ts

@@ -1,26 +1,36 @@
-import { resolve } from "node:path";
-
-import { loadConfig } from "../config/loadConfig.js";
-
-/** Parse shared CLI flags used across nifty commands. */
-export function parseCliContext(argv: string[]): { cwd: string; dryRun: boolean } {
-    let cwd = process.cwd();
-    let dryRun = false;
-
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--dry-run") {
-            dryRun = true;
-        } else if (arg === "-C" || arg === "--cwd") {
-            cwd = resolve(argv[++i] ?? cwd);
-        }
-    }
-
-    return { cwd, dryRun };
-}
-
-/** Ensure `nifty.config.*` exists before running a command (skip create on `--dry-run`). */
-export async function bootstrapNiftyConfig(argv: string[]): Promise<void> {
-    const { cwd, dryRun } = parseCliContext(argv);
-    await loadConfig({ cwd, createIfMissing: !dryRun });
-}
+import { resolve } from "node:path";
+
+import type { ParsedOptions } from "@vmz/commander";
+
+import { loadConfig } from "../config/loadConfig.js";
+import { cwdFrom } from "./options.js";
+
+/** Parse shared CLI flags used across nifty commands. */
+export function parseCliContext(argv: string[]): { cwd: string; dryRun: boolean } {
+    let cwd = process.cwd();
+    let dryRun = false;
+
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--dry-run") {
+            dryRun = true;
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = resolve(argv[++i] ?? cwd);
+        }
+    }
+
+    return { cwd, dryRun };
+}
+
+/** Ensure `nifty.config.*` exists before running a command (skip create on `--dry-run`). */
+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> {
+    const cwd = cwdFrom(options) ?? process.cwd();
+    const dryRun = options["dry-run"] === true;
+    await loadConfig({ cwd, createIfMissing: !dryRun });
+}

package/src/cli/index.ts

@@ -1,8 +1,9 @@
-export { runCli } from "./main.js";
-export { bumpSemver, bumpWorkspace, runBump, type BumpKind, type BumpOptions, type BumpReport } from "./bump.js";
-export { runPublish, type PublishOptions, type PublishReport } from "./publish.js";
-export { runTrust, type TrustReport } from "./trust.js";
-export { runUpdate } from "./update.js";
-export { runLint } from "./lint.js";
-export { runUpload } from "./upload.js";
-export { findWorkspaceRoot, listWorkspacePackages, type WorkspacePackage } from "./workspace.js";
+export { runCli } from "./main.js";
+export { bumpSemver, bumpWorkspace, runBump, type BumpKind, type BumpOptions, type BumpReport } from "./bump.js";
+export { runPublish, type PublishOptions, type PublishReport } from "./publish.js";
+export { runTrust, type TrustReport } from "./trust.js";
+export { runUpdate } from "./update.js";
+export { runLint } from "./lint.js";
+export { runUpload } from "./upload.js";
+export { installNativeFromOptions, type InstallNativeOptions } from "./install-native.js";
+export { findWorkspaceRoot, listWorkspacePackages, type WorkspacePackage } from "./workspace.js";

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

@@ -0,0 +1,22 @@
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { installNativeFromOptions } from "./install-native.js";
+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));
+}
+
+export async function cmdInstallNative(options: ParsedOptions): Promise<number> {
+    const from =
+        str(options, "from") ??
+        process.env.NATIVE_ARTIFACT_ROOT ??
+        "native-artifacts";
+    installNativeFromOptions({
+        from,
+        cwd: cwdFrom(options),
+    });
+    return 0;
+}

package/src/cli/install-native.ts

@@ -0,0 +1,80 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+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> = {
+    "nifty-win32-x64-msvc.node": "nifty-win32-x64",
+    "nifty-linux-x64-gnu.node": "nifty-linux-x64",
+    "nifty-linux-arm64-gnu.node": "nifty-linux-arm64",
+    "nifty-darwin-x64.node": "nifty-darwin-x64",
+    "nifty-darwin-arm64.node": "nifty-darwin-arm64",
+};
+
+/** Matrix platforms that must be present after install (matches publish-npm.yml). */
+const REQUIRED_PACKAGES = ["nifty-win32-x64", "nifty-linux-x64", "nifty-darwin-arm64"];
+
+export type InstallNativeOptions = {
+    /** Downloaded CI artifact tree (walked recursively for .node files). */
+    from: string;
+    cwd?: string;
+};
+
+function walkNodes(dir: string): string[] {
+    const out: string[] = [];
+    if (!existsSync(dir)) {
+        return out;
+    }
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...walkNodes(full));
+        } else if (entry.isFile() && entry.name.endsWith(".node")) {
+            out.push(full);
+        }
+    }
+    return out;
+}
+
+function libHasNode(libDir: string): boolean {
+    return existsSync(libDir) && readdirSync(libDir).some((name) => name.endsWith(".node"));
+}
+
+/** Copy matrix .node artifacts into platform package lib dirs for npm publish. */
+export function installNativeFromOptions(options: InstallNativeOptions): void {
+    const layout = detectProjectLayout(options.cwd ?? process.cwd());
+    const artifactRoot = resolve(layout.root, options.from);
+    const nodes = walkNodes(artifactRoot);
+    if (nodes.length === 0) {
+        throw new Error(`install-native: no .node files under ${artifactRoot}`);
+    }
+
+    let installed = 0;
+    for (const file of nodes) {
+        const base = basename(file);
+        const packageDir = PACKAGE_BY_ASSET[base];
+        if (!packageDir) {
+            console.log(`skip unmapped artifact ${relative(artifactRoot, file)}`);
+            continue;
+        }
+        const dest = join(layout.root, "projects/packages", packageDir, "lib", base);
+        mkdirSync(dirname(dest), { recursive: true });
+        copyFileSync(file, dest);
+        console.log(`installed ${relative(layout.root, dest)}`);
+        installed += 1;
+    }
+
+    if (installed === 0) {
+        throw new Error("install-native: no mapped platform .node files installed");
+    }
+
+    for (const packageDir of REQUIRED_PACKAGES) {
+        const libDir = join(layout.root, "projects/packages", packageDir, "lib");
+        if (!libHasNode(libDir)) {
+            throw new Error(`install-native: missing .node under ${packageDir}/lib`);
+        }
+    }
+
+    console.log(`install-native: ${installed} native binary(ies) ready for npm publish`);
+}

package/src/cli/lint-cmd.ts

@@ -0,0 +1,33 @@
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { bootstrapFromOptions } from "./context.js";
+import { lintCommits, type LintOptions } from "./lint.js";
+import { cwdFrom, str, strList } from "./options.js";
+
+export function registerLintCommands(cli: Cli): void {
+    registerLintLike(cli, "lint", "cli.cmd.lint", false);
+    registerLintLike(cli, "check", "cli.cmd.check", true);
+}
+
+function registerLintLike(cli: Cli, name: string, helpId: string, check: boolean): void {
+    cli.command(name, helpId)
+        .option("--from <ref>", "cli.opt.from")
+        .option("--to <ref>", "cli.opt.to")
+        .option("-s, --subject <text>...", "cli.opt.subject")
+        .action(async (options) => cmdLint(options, check));
+}
+
+export async function cmdLint(options: ParsedOptions, check: boolean): Promise<number> {
+    await bootstrapFromOptions(options);
+    const lintOptions: LintOptions = {
+        subjects: strList(options, "subject"),
+        from: str(options, "from"),
+        to: str(options, "to"),
+        cwd: cwdFrom(options),
+    };
+    const errorCount = await lintCommits(lintOptions, check);
+    if (check && errorCount > 0) {
+        throw new Error(`found ${errorCount} lint error(s)`);
+    }
+    return 0;
+}

package/src/cli/lint.ts

@@ -1,109 +1,113 @@
-import { loadNiftyNative } from "../native.js";
-
-const KNOWN_GITMOJIS = ["✨", "🎨", "🚀", "🐛", "🚑", "🔥", "💥", "♻️", "🔧", "📝", "👷", "🧹", "⬆️", "🧪", "🔨", "📦"];
-
-type LintOptions = {
-    subjects: string[];
-    from?: string;
-    to?: string;
-    cwd?: string;
-};
-
-type LintDiagnostic = {
-    rule: string;
-    severity: "error" | "warning";
-    message: string;
-    subject?: string;
-};
-
-export async function runLint(argv: string[], check: boolean): Promise<void> {
-    const options = parseLintArgs(argv);
-    const native = loadNiftyNative();
-    const subjects: string[] = [];
-
-    if (options.subjects.length > 0) {
-        subjects.push(...options.subjects);
-    } else {
-        const cwd = options.cwd ?? process.cwd();
-        const repoRoot = native.git["discover-root"](cwd);
-        const toRef = options.to ?? "HEAD";
-        const commits = native.git["collect-commits"](repoRoot, options.from, toRef);
-        subjects.push(...commits.map((commit) => commit.subject));
-    }
-
-    const diagnostics = subjects.flatMap((subject) => lintSubject(subject, native));
-    for (const item of diagnostics) {
-        const prefix = item.severity === "error" ? "error" : "warning";
-        const suffix = item.subject ? ` (${item.subject})` : "";
-        console.log(`${prefix} [${item.rule}] ${item.message}${suffix}`);
-    }
-
-    const errorCount = diagnostics.filter((item) => item.severity === "error").length;
-    if (check && errorCount > 0) {
-        throw new Error(`found ${errorCount} lint error(s)`);
-    }
-}
-
-function parseLintArgs(argv: string[]): LintOptions {
-    const options: LintOptions = { subjects: [] };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        if (arg === "--from") {
-            options.from = argv[++i];
-        } else if (arg === "--to") {
-            options.to = argv[++i];
-        } else if (arg === "-C" || arg === "--cwd") {
-            options.cwd = argv[++i];
-        } else if (arg === "-s" || arg === "--subject") {
-            options.subjects.push(argv[++i]);
-        }
-    }
-    return options;
-}
-
-function lintSubject(subject: string, native: ReturnType<typeof loadNiftyNative>): LintDiagnostic[] {
-    const out: LintDiagnostic[] = [];
-    if (!native.gitmoji["validate-subject"](subject)) {
-        out.push({
-            rule: "gitmoji/subject",
-            severity: "error",
-            message: "commit subject must start with a known gitmoji followed by a space",
-            subject,
-        });
-        return out;
-    }
-
-    const gitmoji = native.gitmoji["leading-gitmoji"](subject);
-    if (gitmoji && !KNOWN_GITMOJIS.includes(gitmoji)) {
-        out.push({
-            rule: "gitmoji/known",
-            severity: "error",
-            message: `gitmoji ${gitmoji} is not in the Nifty known gitmoji list`,
-            subject,
-        });
-    }
-
-    const body = native.gitmoji["strip-gitmoji"](subject).trim();
-    if (!body) {
-        out.push({
-            rule: "gitmoji/body",
-            severity: "warning",
-            message: "commit subject body must not be empty after the gitmoji prefix",
-            subject,
-        });
-    }
-
-    if (gitmoji) {
-        const expected = native.gitmoji["format-subject"](gitmoji, body);
-        if (expected !== subject.trim()) {
-            out.push({
-                rule: "gitmoji/format",
-                severity: "warning",
-                message: `subject should be formatted as ${expected}`,
-                subject,
-            });
-        }
-    }
-
-    return out;
-}
+import { loadNiftyNative } from "../native.js";
+
+const KNOWN_GITMOJIS = ["✨", "🎨", "🚀", "🐛", "🚑", "🔥", "💥", "♻️", "🔧", "📝", "👷", "🧹", "⬆️", "🧪", "🔨", "📦"];
+
+export type LintOptions = {
+    subjects: string[];
+    from?: string;
+    to?: string;
+    cwd?: string;
+};
+
+type LintDiagnostic = {
+    rule: string;
+    severity: "error" | "warning";
+    message: string;
+    subject?: string;
+};
+
+export async function runLint(argv: string[], check: boolean): Promise<void> {
+    const options = parseLintArgs(argv);
+    const errorCount = await lintCommits(options, check);
+    if (check && errorCount > 0) {
+        throw new Error(`found ${errorCount} lint error(s)`);
+    }
+}
+
+export async function lintCommits(options: LintOptions, check: boolean): Promise<number> {
+    const native = loadNiftyNative();
+    const subjects: string[] = [];
+
+    if (options.subjects.length > 0) {
+        subjects.push(...options.subjects);
+    } else {
+        const cwd = options.cwd ?? process.cwd();
+        const repoRoot = native.git["discover-root"](cwd);
+        const toRef = options.to ?? "HEAD";
+        const commits = native.git["collect-commits"](repoRoot, options.from, toRef);
+        subjects.push(...commits.map((commit) => commit.subject));
+    }
+
+    const diagnostics = subjects.flatMap((subject) => lintSubject(subject, native));
+    for (const item of diagnostics) {
+        const prefix = item.severity === "error" ? "error" : "warning";
+        const suffix = item.subject ? ` (${item.subject})` : "";
+        console.log(`${prefix} [${item.rule}] ${item.message}${suffix}`);
+    }
+
+    return diagnostics.filter((item) => item.severity === "error").length;
+}
+
+function parseLintArgs(argv: string[]): LintOptions {
+    const options: LintOptions = { subjects: [] };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--from") {
+            options.from = argv[++i];
+        } else if (arg === "--to") {
+            options.to = argv[++i];
+        } else if (arg === "-C" || arg === "--cwd") {
+            options.cwd = argv[++i];
+        } else if (arg === "-s" || arg === "--subject") {
+            options.subjects.push(argv[++i]);
+        }
+    }
+    return options;
+}
+
+function lintSubject(subject: string, native: ReturnType<typeof loadNiftyNative>): LintDiagnostic[] {
+    const out: LintDiagnostic[] = [];
+    if (!native.gitmoji["validate-subject"](subject)) {
+        out.push({
+            rule: "gitmoji/subject",
+            severity: "error",
+            message: "commit subject must start with a known gitmoji followed by a space",
+            subject,
+        });
+        return out;
+    }
+
+    const gitmoji = native.gitmoji["leading-gitmoji"](subject);
+    if (gitmoji && !KNOWN_GITMOJIS.includes(gitmoji)) {
+        out.push({
+            rule: "gitmoji/known",
+            severity: "error",
+            message: `gitmoji ${gitmoji} is not in the Nifty known gitmoji list`,
+            subject,
+        });
+    }
+
+    const body = native.gitmoji["strip-gitmoji"](subject).trim();
+    if (!body) {
+        out.push({
+            rule: "gitmoji/body",
+            severity: "warning",
+            message: "commit subject body must not be empty after the gitmoji prefix",
+            subject,
+        });
+    }
+
+    if (gitmoji) {
+        const expected = native.gitmoji["format-subject"](gitmoji, body);
+        if (expected !== subject.trim()) {
+            out.push({
+                rule: "gitmoji/format",
+                severity: "warning",
+                message: `subject should be formatted as ${expected}`,
+                subject,
+            });
+        }
+    }
+
+    return out;
+}

package/src/cli/main.ts

@@ -1,64 +1 @@
-import { runBump } from "./bump.js";
-import { bootstrapNiftyConfig } from "./context.js";
-import { runLint } from "./lint.js";
-import { runPublish } from "./publish.js";
-import { runTrust } from "./trust.js";
-import { runUpdate } from "./update.js";
-import { runUpload } from "./upload.js";
-
-export async function runCli(argv: string[]): Promise<number> {
-    const [command, ...rest] = argv;
-
-    if (!command || command === "-h" || command === "--help") {
-        printHelp();
-        return 0;
-    }
-
-    try {
-        await bootstrapNiftyConfig(rest);
-        switch (command) {
-            case "update":
-                await runUpdate(rest);
-                return 0;
-            case "lint":
-                await runLint(rest, false);
-                return 0;
-            case "check":
-                await runLint(rest, true);
-                return 0;
-            case "upload":
-                await runUpload(rest);
-                return 0;
-            case "bump":
-                await runBump(rest);
-                return 0;
-            case "publish":
-                await runPublish(rest);
-                return 0;
-            case "trust":
-                await runTrust(rest);
-                return 0;
-            default:
-                console.error(`unknown command: ${command}`);
-                printHelp();
-                return 1;
-        }
-    } catch (error) {
-        console.error(`error: ${error instanceof Error ? error.message : String(error)}`);
-        return 1;
-    }
-}
-
-function printHelp(): void {
-    console.log(`nifty — Nifty tooling for hybrid cargo + npm projects
-
-Usage:
-  nifty update [-i] [-C cwd]
-  nifty lint [--from ref] [--to ref] [-s subject] [-C cwd]
-  nifty check [--from ref] [--to ref] [-s subject] [-C cwd]
-  nifty upload (--release | --pages | --both) [options]
-  nifty bump [patch|minor|major|version] [--dry-run] [-C cwd]
-  nifty publish [--dry-run] [--tag <tag>] [--access public] [-C cwd]
-  nifty trust [--only <pkg>] [--dry-run] [-C cwd]
-`);
-}
+export { runCli } from "./cli.js";

package/src/cli/options.ts

@@ -0,0 +1,40 @@
+import { resolve } from "node:path";
+
+import type { ParsedOptions } from "@vmz/commander";
+
+import { resolveNpmExecutable } from "./resolveNpm.js";
+import type { AuthCliOptions } from "./authArgs.js";
+
+export function cwdFrom(options: ParsedOptions): string | undefined {
+    const value = options.cwd;
+    return typeof value === "string" && value.length > 0 ? resolve(value) : undefined;
+}
+
+export function flag(options: ParsedOptions, key: string): boolean {
+    return options[key] === true;
+}
+
+export function str(options: ParsedOptions, key: string): string | undefined {
+    const value = options[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export function strList(options: ParsedOptions, key: string): string[] {
+    const value = options[key];
+    if (Array.isArray(value)) {
+        return value.filter((entry): entry is string => typeof entry === "string" && entry.length > 0);
+    }
+    if (typeof value === "string" && value.length > 0) {
+        return [value];
+    }
+    return [];
+}
+
+export function authFromOptions(options: ParsedOptions): AuthCliOptions {
+    return {
+        otp: str(options, "otp"),
+        totpSecret: str(options, "totp-secret"),
+        token: str(options, "npm-token") ?? str(options, "token"),
+        npm: resolveNpmExecutable(),
+    };
+}

package/src/cli/publish-cmd.ts

@@ -0,0 +1,34 @@
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { loadNiftyNative } from "../native.js";
+import { authPayload } from "./authArgs.js";
+import { bootstrapFromOptions } from "./context.js";
+import { printPublishReport } from "./publish.js";
+import { authFromOptions, cwdFrom, flag, str } from "./options.js";
+
+export function registerPublishCommand(cli: Cli): void {
+    cli.command("publish", "cli.cmd.publish")
+        .option("--dry-run", "cli.opt.dry-run")
+        .option("--refresh", "cli.opt.refresh")
+        .option("--tag <tag>", "cli.opt.tag")
+        .option("--access <access>", "cli.opt.access")
+        .option("--otp <code>", "cli.opt.otp")
+        .option("--totp-secret <secret>", "cli.opt.totp-secret")
+        .option("--npm-token <token>", "cli.opt.npm-token")
+        .action(async (options) => cmdPublish(options));
+}
+
+export async function cmdPublish(options: ParsedOptions): Promise<number> {
+    await bootstrapFromOptions(options);
+    const native = loadNiftyNative();
+    const report = native.publisher["publish-workspace"]({
+        cwd: cwdFrom(options),
+        dryRun: flag(options, "dry-run"),
+        refresh: flag(options, "refresh"),
+        tag: str(options, "tag"),
+        access: str(options, "access") ?? "public",
+        ...authPayload(authFromOptions(options)),
+    });
+    printPublishReport(report, flag(options, "dry-run"));
+    return 0;
+}