@doki-land/nifty 0.0.1 → 0.0.2

package/locales/en-US/cli.json

@@ -8,6 +8,13 @@
   "cli.cmd.bump": "Align workspace crate and package versions",
   "cli.cmd.publish": "Publish workspace npm packages (OIDC or token + TOTP)",
   "cli.cmd.trust": "Configure npm Trusted Publisher for workspace packages",
+  "cli.cmd.reword": "Rewrite commit messages at the git object layer",
+  "cli.cmd.reword.export": "Export a JSON reword map template",
+  "cli.cmd.reword.rewrite": "Rewrite commits from a JSON map and update the branch ref",
+  "cli.cmd.retime": "Spread commit timestamps across a date range on a new branch",
+  "cli.cmd.retime.root": "Retime all commits from repository root through tip",
+  "cli.cmd.change-logs": "Draft release reference changelogs from git tags",
+  "cli.cmd.change-logs.lookup": "Look up GitHub user id/login from email or login",
   "cli.opt.cwd": "Working directory",
   "cli.opt.interactive": "Prompt before applying dependency updates",
   "cli.opt.from": "Start git ref for commit range",
@@ -37,5 +44,21 @@
   "cli.opt.only": "Limit trust to one package name",
   "cli.opt.otp": "One-time npm password (6 digits)",
   "cli.opt.totp-secret": "Base32 TOTP secret (overrides env)",
-  "cli.opt.npm-token": "npm auth token (overrides NPM_TOKEN)"
+  "cli.opt.npm-token": "npm auth token (overrides NPM_TOKEN)",
+  "cli.opt.base": "Exclusive range start commit (e.g. 34e1e665^)",
+  "cli.opt.ref": "Branch ref to rewrite (default: HEAD)",
+  "cli.opt.path": "Path to reword JSON map (default: reword.pending.json)",
+  "cli.opt.start-date": "Random window start (YYYY-MM-DD or ISO datetime)",
+  "cli.opt.end-date": "Random window end",
+  "cli.opt.branch": "Output branch name (default: time-travel)",
+  "cli.opt.tip": "Range end revision (default: HEAD)",
+  "cli.opt.message": "Optional new message for the root commit (retime root)",
+  "cli.opt.write": "Write documentation/maintenance/releases/vX.Y.Z.reference.md",
+  "cli.opt.tags": "List version tags with short hashes",
+  "cli.opt.author-map": "Path to author-github.json",
+  "cli.opt.releases-dir": "Releases directory for --write",
+  "cli.opt.email": "Author email to resolve",
+  "cli.opt.login": "GitHub login to resolve",
+  "cli.opt.github-token": "GitHub token for search-by-email",
+  "cli.opt.fetch": "Fetch missing numeric id from GitHub API"
 }

package/package.json

@@ -1,16 +1,12 @@
 {
+  "name": "@doki-land/nifty",
+  "version": "0.0.2",
+  "description": "Gitmoji-first commit conventions and release helpers (Node-API + TypeScript)",
+  "type": "module",
+  "license": "MPL-2.0",
   "bin": {
     "nifty": "cli/nifty.mjs"
   },
-  "dependencies": {
-    "@vmz/commander": "^0.2.0",
-    "jiti": "^2.4.2"
-  },
-  "description": "Gitmoji-first commit conventions and release helpers (Node-API + TypeScript)",
-  "devDependencies": {
-    "@types/node": "^22.13.10",
-    "typescript": "^5.8.3"
-  },
   "exports": {
     ".": "./src/index.ts",
     "./cli": "./src/cli/index.ts"
@@ -20,12 +16,17 @@
     "locales",
     "src"
   ],
-  "license": "MPL-2.0",
-  "name": "@doki-land/nifty",
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@vmz/commander": "^0.2.0",
+    "jiti": "^2.4.2"
+  },
   "optionalDependencies": {
-    "@doki-land/nifty-darwin-arm64": "0.0.1",
-    "@doki-land/nifty-linux-x64": "0.0.1",
-    "@doki-land/nifty-win32-x64": "0.0.1"
+    "@doki-land/nifty-win32-x64": "0.0.2",
+    "@doki-land/nifty-linux-x64": "0.0.2",
+    "@doki-land/nifty-darwin-arm64": "0.0.2"
   },
   "publishConfig": {
     "access": "public"
@@ -33,10 +34,5 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oovm/npm-tools.git"
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit"
-  },
-  "type": "module",
-  "version": "0.0.1"
+  }
 }

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

@@ -0,0 +1,97 @@
+import { join } from "node:path";
+
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { loadConfig } from "../config/loadConfig.js";
+import { loadNiftyNative } from "../native.js";
+import { bootstrapFromOptions } from "./context.js";
+import { cwdFrom, flag, str } from "./options.js";
+
+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")
+        .option("--to <ref>", "cli.opt.to")
+        .option("--write", "cli.opt.write")
+        .option("--tags", "cli.opt.tags")
+        .option("--repo <owner/name>", "cli.opt.repo")
+        .option("--author-map <path>", "cli.opt.author-map")
+        .option("--releases-dir <path>", "cli.opt.releases-dir");
+
+    changeLogs
+        .command("lookup", "cli.cmd.change-logs.lookup")
+        .option("--email <email>", "cli.opt.email")
+        .option("--login <login>", "cli.opt.login")
+        .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));
+
+    changeLogs.action(async (options) => cmdChangeLogsRender(options));
+}
+
+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 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") ?? config.changelog?.authorMap,
+        releasesDir: str(options, "releases-dir") ?? config.changelog?.releasesDir,
+    });
+
+    if (flag(options, "tags")) {
+        console.log(report.notes);
+        return 0;
+    }
+
+    if (report.rangeLabel) {
+        console.error(`change-logs: ${report.rangeLabel} — ${report.commitCount} commit(s)`);
+    }
+    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> {
+    await bootstrapFromOptions(options);
+    const cwd = cwdFrom(options) ?? process.cwd();
+    const { config } = await loadConfig({ cwd, createIfMissing: false });
+    const email = str(options, "email");
+    const login = str(options, "login");
+    if (!email && !login) {
+        throw new Error("lookup requires --email or --login");
+    }
+    const native = loadNiftyNative();
+    const author = native.history["changelog-lookup"]({
+        cwd,
+        email,
+        login,
+        map: str(options, "map") ?? config.changelog?.authorMap,
+        githubToken: str(options, "github-token") ?? config.githubToken ?? process.env.GITHUB_TOKEN,
+        fetch: flag(options, "fetch"),
+    });
+    const json: Record<string, unknown> = {};
+    if (author.id !== undefined) {
+        json.id = author.id;
+    }
+    if (author.login) {
+        json.login = author.login;
+    }
+    console.log(JSON.stringify(json, null, 2));
+    return 0;
+}
+
+/** Default author map path relative to repo root (matches git-change-logs). */
+export function defaultAuthorMapPath(repoRoot: string): string {
+    return join(repoRoot, "documentation/maintenance/author-github.json");
+}

package/src/cli/cli.ts

@@ -4,9 +4,12 @@ import { fileURLToPath } from "node:url";
 import { createCli } from "@vmz/commander";
 
 import { registerBumpCommand } from "./bump-cmd.js";
+import { registerChangeLogsCommand } from "./change-logs-cmd.js";
 import { registerInstallNativeCommand } from "./install-native-cmd.js";
 import { registerLintCommands } from "./lint-cmd.js";
 import { registerPublishCommand } from "./publish-cmd.js";
+import { registerRetimeCommand } from "./retime-cmd.js";
+import { registerRewordCommand } from "./reword-cmd.js";
 import { registerTrustCommand } from "./trust-cmd.js";
 import { registerUpdateCommand } from "./update-cmd.js";
 import { registerUploadCommand } from "./upload-cmd.js";
@@ -25,6 +28,9 @@ function buildNiftyCli() {
     registerBumpCommand(cli);
     registerPublishCommand(cli);
     registerTrustCommand(cli);
+    registerRewordCommand(cli);
+    registerRetimeCommand(cli);
+    registerChangeLogsCommand(cli);
 
     return cli;
 }

package/src/cli/retime-cmd.ts

@@ -0,0 +1,62 @@
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { loadNiftyNative } from "../native.js";
+import { bootstrapFromOptions } from "./context.js";
+import { cwdFrom, str } from "./options.js";
+
+export function registerRetimeCommand(cli: Cli): void {
+    const retime = cli.command("retime", "cli.cmd.retime")
+        .option("-s, --start-date <start>", "cli.opt.start-date")
+        .option("--end-date <end>", "cli.opt.end-date")
+        .option("-b, --branch <branch>", "cli.opt.branch")
+        .option("--tip <ref>", "cli.opt.tip");
+
+    retime
+        .command("root", "cli.cmd.retime.root")
+        .option("-s, --start-date <start>", "cli.opt.start-date")
+        .option("--end-date <end>", "cli.opt.end-date")
+        .option("-b, --branch <branch>", "cli.opt.branch")
+        .option("--tip <ref>", "cli.opt.tip")
+        .option("-m, --message <text>", "cli.opt.message")
+        .action(async (options) => cmdRetimeRoot(options));
+
+    retime.action(async (options) => cmdRetimeRange(options));
+}
+
+export async function cmdRetimeRange(options: ParsedOptions): Promise<number> {
+    await bootstrapFromOptions(options);
+    const commit = options._[0];
+    if (!commit) {
+        throw new Error("missing commit hash for range retime");
+    }
+    const native = loadNiftyNative();
+    const report = native.history["retime-range"]({
+        cwd: cwdFrom(options),
+        commit,
+        startDate: str(options, "start-date"),
+        endDate: str(options, "end-date"),
+        branch: str(options, "branch"),
+        tip: str(options, "tip"),
+    });
+    printRetimeSummary(report);
+    return 0;
+}
+
+export async function cmdRetimeRoot(options: ParsedOptions): Promise<number> {
+    await bootstrapFromOptions(options);
+    const native = loadNiftyNative();
+    const report = native.history["retime-root"]({
+        cwd: cwdFrom(options),
+        startDate: str(options, "start-date"),
+        endDate: str(options, "end-date"),
+        branch: str(options, "branch"),
+        tip: str(options, "tip"),
+        message: str(options, "message"),
+    });
+    printRetimeSummary(report);
+    return 0;
+}
+
+function printRetimeSummary(report: { rewritten: number; branch: string; newTip: string }): void {
+    console.log(`retimed ${report.rewritten} commit(s) on branch ${report.branch}; tip ${report.newTip}`);
+}

package/src/cli/reword-cmd.ts

@@ -0,0 +1,87 @@
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { loadNiftyNative } from "../native.js";
+import { bootstrapFromOptions } from "./context.js";
+import { cwdFrom, flag, str } from "./options.js";
+
+export function registerRewordCommand(cli: Cli): void {
+    const reword = cli.command("reword", "cli.cmd.reword");
+
+    reword
+        .command("export", "cli.cmd.reword.export")
+        .option("--base <ref>", "cli.opt.base")
+        .option("--ref <ref>", "cli.opt.ref")
+        .option("--path <file>", "cli.opt.path")
+        .action(async (options) => cmdRewordExport(options));
+
+    reword
+        .command("rewrite", "cli.cmd.reword.rewrite")
+        .option("--base <ref>", "cli.opt.base")
+        .option("--ref <ref>", "cli.opt.ref")
+        .option("--path <file>", "cli.opt.path")
+        .option("--dry-run", "cli.opt.dry-run")
+        .action(async (options) => cmdRewordRewrite(options));
+}
+
+export async function cmdRewordExport(options: ParsedOptions): Promise<number> {
+    await bootstrapFromOptions(options);
+    const base = requireStr(options, "base");
+    const path = str(options, "path") ?? "reword.pending.json";
+    const native = loadNiftyNative();
+    const report = native.history["reword-export"]({
+        cwd: cwdFrom(options),
+        base,
+        ref: str(options, "ref"),
+        path,
+    });
+    console.log(`export: wrote ${report.count} commit entry(ies) to ${report.path}`);
+    return 0;
+}
+
+export async function cmdRewordRewrite(options: ParsedOptions): Promise<number> {
+    await bootstrapFromOptions(options);
+    const base = requireStr(options, "base");
+    const path = requireStr(options, "path");
+    const dryRun = flag(options, "dry-run");
+    const native = loadNiftyNative();
+    const report = native.history["reword-rewrite"]({
+        cwd: cwdFrom(options),
+        base,
+        ref: str(options, "ref"),
+        path,
+        dryRun,
+    });
+
+    if (dryRun) {
+        if (report.changes.length === 0) {
+            console.log("dry-run: no commit objects need rewriting");
+            return 0;
+        }
+        console.log(`dry-run: ${report.changes.length} commit object(s) would be rewritten on ${report.refName}\n`);
+        for (const change of report.changes) {
+            console.log(`${change.oldOid}  ${change.oldSubject}`);
+            console.log(`     ->  ${change.newSubject}`);
+            if (change.parentsRelinked && !change.messageChanged) {
+                console.log("     (parent chain relink only)");
+            }
+            console.log();
+        }
+        return 0;
+    }
+
+    console.log(
+        `rewrote ${report.changes.length} commit object(s); ${report.oldTip} -> ${report.newTip ?? report.oldTip}`,
+    );
+    for (const change of report.changes) {
+        console.log(`  ${change.oldOid}  ${change.newSubject}`);
+    }
+    return 0;
+}
+
+function requireStr(options: ParsedOptions, key: string): string {
+    const value = str(options, key);
+    if (!value) {
+        throw new Error(`missing required --${key}`);
+    }
+    return value;
+}

package/src/cli/trust-cmd.ts

@@ -2,6 +2,7 @@ import type { Cli, ParsedOptions } from "@vmz/commander";
 
 import { loadNiftyNative } from "../native.js";
 import { authPayload } from "./authArgs.js";
+import { loadConfig } from "../config/loadConfig.js";
 import { bootstrapFromOptions } from "./context.js";
 import { printTrustReport } from "./trust.js";
 import { authFromOptions, cwdFrom, flag, str } from "./options.js";
@@ -19,12 +20,14 @@ export function registerTrustCommand(cli: Cli): void {
 
 export async function cmdTrust(options: ParsedOptions): Promise<number> {
     await bootstrapFromOptions(options);
+    const { config } = await loadConfig({ cwd: cwdFrom(options), createIfMissing: false });
     const native = loadNiftyNative();
     const report = native.publisher["trust-workspace"]({
         cwd: cwdFrom(options),
         dryRun: flag(options, "dry-run"),
         refresh: flag(options, "refresh"),
         only: str(options, "only"),
+        packages: config.publish?.packages,
         ...authPayload(authFromOptions(options)),
     });
     printTrustReport(report);

package/src/config/types.ts

@@ -16,6 +16,20 @@ export type NiftyConfig = {
     cargoRoot?: string;
     /** npm package root override. */
     npmRoot?: string;
+    /** npm publish / Trusted Publisher (CI uses publish-npm.yml). */
+    publish?: {
+        /** Package names to trust (includes registry-only native sidecars). */
+        packages?: string[];
+    };
+    /** Release reference changelog defaults (`nifty change-logs`). */
+    changelog?: {
+        /** GitHub `owner/repo` for contrib.rocks (default: parse `origin`). */
+        repo?: string;
+        /** Email → GitHub map path (default: `documentation/maintenance/author-github.json`). */
+        authorMap?: string;
+        /** `--write` output directory (default: `documentation/maintenance/releases`). */
+        releasesDir?: string;
+    };
     /** Rule-based lint configuration. */
     lint?: {
         rules?: Array<{

package/src/native.ts

@@ -68,6 +68,81 @@ export type TrustReport = {
     failed: string[];
 };
 
+export type RewordPlannedChange = {
+    oldOid: string;
+    oldSubject: string;
+    newSubject: string;
+    parentsRelinked: boolean;
+    messageChanged: boolean;
+};
+
+export type RewordRewriteReport = {
+    changes: RewordPlannedChange[];
+    oldTip: string;
+    newTip?: string;
+    refName: string;
+    dryRun: boolean;
+};
+
+export type HistoryExports = {
+    "reword-export": (options: {
+        cwd?: string;
+        base: string;
+        ref?: string;
+        path: string;
+    }) => { count: number; path: string };
+    "reword-rewrite": (options: {
+        cwd?: string;
+        base: string;
+        ref?: string;
+        path: string;
+        dryRun?: boolean;
+    }) => RewordRewriteReport;
+    "retime-range": (options: {
+        cwd?: string;
+        commit: string;
+        startDate?: string;
+        endDate?: string;
+        branch?: string;
+        tip?: string;
+    }) => { branch: string; newTip: string; rewritten: number };
+    "retime-root": (options: {
+        cwd?: string;
+        startDate?: string;
+        endDate?: string;
+        branch?: string;
+        tip?: string;
+        message?: string;
+    }) => { branch: string; newTip: string; rewritten: number };
+    "changelog-render": (options: {
+        cwd?: string;
+        version?: string;
+        fromRef?: string;
+        toRef?: string;
+        write?: boolean;
+        tags?: boolean;
+        repo?: string;
+        authorMap?: string;
+        releasesDir?: string;
+    }) => {
+        notes: string;
+        version: string;
+        fromRef?: string;
+        toRef: string;
+        commitCount: number;
+        writtenPath?: string;
+        rangeLabel: string;
+    };
+    "changelog-lookup": (options: {
+        cwd?: string;
+        email?: string;
+        login?: string;
+        map?: string;
+        githubToken?: string;
+        fetch?: boolean;
+    }) => GithubAuthor;
+};
+
 export type PublisherExports = {
     "publish-workspace": (options: {
         cwd?: string;
@@ -85,6 +160,7 @@ export type PublisherExports = {
         dryRun?: boolean;
         refresh?: boolean;
         only?: string;
+        packages?: string[];
         npm?: string;
         otp?: string;
         totpSecret?: string;
@@ -95,6 +171,7 @@ export type PublisherExports = {
 export type NiftyNative = {
     gitmoji: GitmojiExports;
     git: GitExports;
+    history: HistoryExports;
     publisher: PublisherExports;
 };
 
@@ -146,11 +223,80 @@ type NativeBinding = {
         dryRun?: boolean | null;
         refresh?: boolean | null;
         only?: string | null;
+        packages?: string[] | null;
         npm?: string | null;
         otp?: string | null;
         totpSecret?: string | null;
         token?: string | null;
     }) => TrustReport;
+    gitToolsRewordExport: (options: {
+        cwd?: string | null;
+        base: string;
+        ref?: string | null;
+        path: string;
+    }) => { count: number; path: string };
+    gitToolsRewordRewrite: (options: {
+        cwd?: string | null;
+        base: string;
+        ref?: string | null;
+        path: string;
+        dryRun?: boolean | null;
+    }) => {
+        changes: Array<{
+            oldOid: string;
+            oldSubject: string;
+            newSubject: string;
+            parentsRelinked: boolean;
+            messageChanged: boolean;
+        }>;
+        oldTip: string;
+        newTip?: string | null;
+        refName: string;
+        dryRun: boolean;
+    };
+    gitToolsRetimeRange: (options: {
+        cwd?: string | null;
+        commit: string;
+        startDate?: string | null;
+        endDate?: string | null;
+        branch?: string | null;
+        tip?: string | null;
+    }) => { branch: string; newTip: string; rewritten: number };
+    gitToolsRetimeRoot: (options: {
+        cwd?: string | null;
+        startDate?: string | null;
+        endDate?: string | null;
+        branch?: string | null;
+        tip?: string | null;
+        message?: string | null;
+    }) => { branch: string; newTip: string; rewritten: number };
+    gitToolsChangelogRender: (options: {
+        cwd?: string | null;
+        version?: string | null;
+        fromRef?: string | null;
+        toRef?: string | null;
+        write?: boolean | null;
+        tags?: boolean | null;
+        repo?: string | null;
+        authorMap?: string | null;
+        releasesDir?: string | null;
+    }) => {
+        notes: string;
+        version: string;
+        fromRef?: string | null;
+        toRef: string;
+        commitCount: number;
+        writtenPath?: string | null;
+        rangeLabel: string;
+    };
+    gitToolsChangelogLookup: (options: {
+        cwd?: string | null;
+        email?: string | null;
+        login?: string | null;
+        map?: string | null;
+        githubToken?: string | null;
+        fetch?: boolean | null;
+    }) => GithubAuthor;
 };
 
 const PLATFORM_PACKAGES: Record<string, string> = {
@@ -213,6 +359,82 @@ function wrapBinding(binding: NativeBinding): NiftyNative {
             "detect-github-repo": (repoRoot) => binding.gitDetectGithubRepo(repoRoot) ?? undefined,
             "parse-github-remote": (url) => binding.gitParseGithubRemote(url) ?? undefined,
         },
+        history: {
+            "reword-export": (options) =>
+                binding.gitToolsRewordExport({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    base: options.base,
+                    ...(options.ref !== undefined ? { ref: options.ref } : {}),
+                    path: options.path,
+                }),
+            "reword-rewrite": (options) => {
+                const report = binding.gitToolsRewordRewrite({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    base: options.base,
+                    ...(options.ref !== undefined ? { ref: options.ref } : {}),
+                    path: options.path,
+                    ...(options.dryRun !== undefined ? { dryRun: options.dryRun } : {}),
+                });
+                return {
+                    changes: report.changes,
+                    oldTip: report.oldTip,
+                    newTip: report.newTip ?? undefined,
+                    refName: report.refName,
+                    dryRun: report.dryRun,
+                };
+            },
+            "retime-range": (options) =>
+                binding.gitToolsRetimeRange({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    commit: options.commit,
+                    ...(options.startDate !== undefined ? { startDate: options.startDate } : {}),
+                    ...(options.endDate !== undefined ? { endDate: options.endDate } : {}),
+                    ...(options.branch !== undefined ? { branch: options.branch } : {}),
+                    ...(options.tip !== undefined ? { tip: options.tip } : {}),
+                }),
+            "retime-root": (options) =>
+                binding.gitToolsRetimeRoot({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    ...(options.startDate !== undefined ? { startDate: options.startDate } : {}),
+                    ...(options.endDate !== undefined ? { endDate: options.endDate } : {}),
+                    ...(options.branch !== undefined ? { branch: options.branch } : {}),
+                    ...(options.tip !== undefined ? { tip: options.tip } : {}),
+                    ...(options.message !== undefined ? { message: options.message } : {}),
+                }),
+            "changelog-render": (options) => {
+                const report = binding.gitToolsChangelogRender({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    ...(options.version !== undefined ? { version: options.version } : {}),
+                    ...(options.fromRef !== undefined ? { fromRef: options.fromRef } : {}),
+                    ...(options.toRef !== undefined ? { toRef: options.toRef } : {}),
+                    ...(options.write !== undefined ? { write: options.write } : {}),
+                    ...(options.tags !== undefined ? { tags: options.tags } : {}),
+                    ...(options.repo !== undefined ? { repo: options.repo } : {}),
+                    ...(options.authorMap !== undefined ? { authorMap: options.authorMap } : {}),
+                    ...(options.releasesDir !== undefined ? { releasesDir: options.releasesDir } : {}),
+                });
+                return {
+                    notes: report.notes,
+                    version: report.version,
+                    fromRef: report.fromRef ?? undefined,
+                    toRef: report.toRef,
+                    commitCount: report.commitCount,
+                    writtenPath: report.writtenPath ?? undefined,
+                    rangeLabel: report.rangeLabel,
+                };
+            },
+            "changelog-lookup": (options) => {
+                const author = binding.gitToolsChangelogLookup({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    ...(options.email !== undefined ? { email: options.email } : {}),
+                    ...(options.login !== undefined ? { login: options.login } : {}),
+                    ...(options.map !== undefined ? { map: options.map } : {}),
+                    ...(options.githubToken !== undefined ? { githubToken: options.githubToken } : {}),
+                    ...(options.fetch !== undefined ? { fetch: options.fetch } : {}),
+                });
+                return mapAuthor(author) ?? {};
+            },
+        },
         publisher: {
             "publish-workspace": (options) =>
                 binding.publisherPublishWorkspace({
@@ -232,6 +454,7 @@ function wrapBinding(binding: NativeBinding): NiftyNative {
                     ...(options.dryRun !== undefined ? { dryRun: options.dryRun } : {}),
                     ...(options.refresh !== undefined ? { refresh: options.refresh } : {}),
                     ...(options.only !== undefined ? { only: options.only } : {}),
+                    ...(options.packages !== undefined ? { packages: options.packages } : {}),
                     ...(options.npm !== undefined ? { npm: options.npm } : {}),
                     ...(options.otp !== undefined ? { otp: options.otp } : {}),
                     ...(options.totpSecret !== undefined ? { totpSecret: options.totpSecret } : {}),

package/Readme.md

@@ -1,30 +0,0 @@
-# @doki-land/nifty
-
-**Gitmoji is the default Nifty convention.**
-
-| Layer | Role |
-| --- | --- |
-| `@doki-land/nifty-<platform>` | Node-API `.node`（gitmoji + gix） |
-| `nifty-publisher` | Rust：`petgraph` 拓扑排序 + `npm publish` |
-| `src/cli/` | CLI 实现（`update` / `lint` / `check` / `upload` / `bump` / `publish`） |
-| `cli/nifty.mjs` | npm `bin` shim（jiti 加载 `src/cli`） |
-| `src/` | TypeScript API |
-
-Rust 侧无 `bin` / `cli`。
-
-**本仓开发**（pnpm workspace，`projects/packages/*`）：
-
-```bash
-pnpm install          # 链接 @doki-land/nifty → node_modules/.bin/nifty
-pnpm run build:napi   # 构建 native addon
-pnpm exec nifty bump
-pnpm exec nifty publish --dry-run
-```
-
-**发布后消费**：
-
-```bash
-npm install @doki-land/nifty
-nifty bump
-nifty publish --dry-run
-```