@doki-land/nifty 0.0.5 → 0.0.7

package/locales/en-US/cli.json

@@ -9,9 +9,14 @@
   "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.commit": "Commit message export, apply, scan, and audit",
+  "cli.cmd.commit.export": "Export a JSON commit message map template",
+  "cli.cmd.commit.apply": "Apply commit message edits from a JSON map and update the branch ref",
+  "cli.cmd.commit.scan": "Scan commit messages for gitmoji and hygiene issues",
+  "cli.cmd.commit.audit": "Audit commit messages and fail on errors",
+  "cli.opt.with-lint": "Run commit lint after export and annotate the JSON map with violations",
+  "cli.opt.json": "Print commit lint output as JSON",
+  "cli.opt.errors-only": "Only report error-level commit lint diagnostics",
   "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",
@@ -51,7 +56,7 @@
   "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.path": "Path to commit JSON map (default: commit.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)",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/nifty",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Gitmoji-first commit conventions and release helpers (Node-API + TypeScript)",
   "type": "module",
   "license": "MPL-2.0",
@@ -24,9 +24,9 @@
     "jiti": "^2.4.2"
   },
   "optionalDependencies": {
-    "@doki-land/nifty-win32-x64": "0.0.5",
-    "@doki-land/nifty-linux-x64": "0.0.5",
-    "@doki-land/nifty-darwin-arm64": "0.0.5"
+    "@doki-land/nifty-win32-x64": "0.0.7",
+    "@doki-land/nifty-linux-x64": "0.0.7",
+    "@doki-land/nifty-darwin-arm64": "0.0.7"
   },
   "publishConfig": {
     "access": "public"

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

@@ -2,6 +2,8 @@ import { join } from "node:path";
 
 import type { Cli, ParsedOptions } from "@vmz/commander";
 
+import { resolveAuthorMapPath } from "../config/authorMap.js";
+import { detectProjectLayout } from "../config/detectProject.js";
 import { loadConfig } from "../config/loadConfig.js";
 import { loadNiftyNative } from "../native.js";
 import { bootstrapFromOptions } from "./context.js";
@@ -34,6 +36,8 @@ export async function cmdChangeLogsRender(options: ParsedOptions): Promise<numbe
     await bootstrapFromOptions(options);
     const cwd = cwdFrom(options) ?? process.cwd();
     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,
@@ -43,7 +47,7 @@ export async function cmdChangeLogsRender(options: ParsedOptions): Promise<numbe
         write: flag(options, "write"),
         tags: flag(options, "tags"),
         repo: str(options, "repo") ?? config.changelog?.repo,
-        authorMap: str(options, "author-map") ?? config.changelog?.authorMap,
+        authorMap: str(options, "author-map") ?? resolveAuthorMapPath(config, repoRoot),
         releasesDir: str(options, "releases-dir") ?? config.changelog?.releasesDir,
     });
 
@@ -66,6 +70,8 @@ export async function cmdChangeLogsLookup(options: ParsedOptions): Promise<numbe
     await bootstrapFromOptions(options);
     const cwd = cwdFrom(options) ?? process.cwd();
     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) {
@@ -76,7 +82,7 @@ export async function cmdChangeLogsLookup(options: ParsedOptions): Promise<numbe
         cwd,
         email,
         login,
-        map: str(options, "map") ?? config.changelog?.authorMap,
+        map: str(options, "map") ?? resolveAuthorMapPath(config, repoRoot),
         githubToken: str(options, "github-token") ?? config.githubToken ?? process.env.GITHUB_TOKEN,
         fetch: flag(options, "fetch"),
     });

package/src/cli/cli.ts

@@ -10,7 +10,7 @@ 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 { registerCommitCommand } from "./commit-cmd.js";
 import { registerTrustCommand } from "./trust-cmd.js";
 import { registerUpdateCommand } from "./update-cmd.js";
 import { registerUploadCommand } from "./upload-cmd.js";
@@ -30,7 +30,7 @@ function buildNiftyCli() {
     registerBumpCommand(cli);
     registerPublishCommand(cli);
     registerTrustCommand(cli);
-    registerRewordCommand(cli);
+    registerCommitCommand(cli);
     registerRetimeCommand(cli);
     registerChangeLogsCommand(cli);
 

package/src/cli/commit-cmd.ts

@@ -0,0 +1,226 @@
+import { readFile, writeFile } from "node:fs/promises";
+
+import type { Cli, ParsedOptions } from "@vmz/commander";
+
+import { loadNiftyNative } from "../native.js";
+import { bootstrapFromOptions } from "./context.js";
+import { lintCommits, type LintOptions } from "./lint.js";
+import { cwdFrom, flag, str, strList } from "./options.js";
+
+export function registerCommitCommand(cli: Cli): void {
+    const commit = cli.command("commit", "cli.cmd.commit");
+
+    commit
+        .command("export", "cli.cmd.commit.export")
+        .option("--base <ref>", "cli.opt.base")
+        .option("--ref <ref>", "cli.opt.ref")
+        .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));
+
+    commit
+        .command("apply", "cli.cmd.commit.apply")
+        .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) => cmdCommitApply(options));
+
+    commit
+        .command("scan", "cli.cmd.commit.scan")
+        .option("--from <ref>", "cli.opt.from")
+        .option("--to <ref>", "cli.opt.to")
+        .option("-s, --subject <text>...", "cli.opt.subject")
+        .option("--json", "cli.opt.json")
+        .option("--errors-only", "cli.opt.errors-only")
+        .action(async (options) => cmdCommitScan(options));
+
+    commit
+        .command("audit", "cli.cmd.commit.audit")
+        .option("--from <ref>", "cli.opt.from")
+        .option("--to <ref>", "cli.opt.to")
+        .option("-s, --subject <text>...", "cli.opt.subject")
+        .option("--json", "cli.opt.json")
+        .option("--errors-only", "cli.opt.errors-only")
+        .action(async (options) => cmdCommitAudit(options));
+}
+
+export async function cmdCommitExport(options: ParsedOptions): Promise<number> {
+    await bootstrapFromOptions(options);
+    const base = requireStr(options, "base");
+    const path = str(options, "path") ?? "commit.pending.json";
+    const native = loadNiftyNative();
+    const report = native.history["commit-export"]({
+        cwd: cwdFrom(options),
+        base,
+        ref: str(options, "ref"),
+        path,
+    });
+    console.log(`export: wrote ${report.count} commit entry(ies) to ${report.path}`);
+
+    if (flag(options, "with-lint")) {
+        const errorCount = await lintAndAnnotateExport({
+            path,
+            from: base,
+            to: str(options, "ref") ?? "HEAD",
+            cwd: cwdFrom(options),
+            json: flag(options, "json"),
+            errorsOnly: flag(options, "errors-only"),
+            reportTitle: "commit export lint",
+        });
+        if (errorCount > 0) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+export async function cmdCommitApply(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["commit-apply"]({
+        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(
+        `applied ${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;
+}
+
+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> {
+    await bootstrapFromOptions(options);
+    const errorCount = await lintCommits(commitLintOptions(options), false, true);
+    return errorCount > 0 ? 1 : 0;
+}
+
+function commitLintOptions(options: ParsedOptions): LintOptions {
+    return {
+        subjects: strList(options, "subject"),
+        from: str(options, "from"),
+        to: str(options, "to"),
+        cwd: cwdFrom(options),
+        scanCargo: false,
+        commitOnly: true,
+        json: flag(options, "json"),
+        errorsOnly: flag(options, "errors-only"),
+        reportTitle: "commit audit",
+    };
+}
+
+type ExportDocument = {
+    version: number;
+    entries: Array<{
+        hash: string;
+        message: string;
+        violations?: Array<{
+            rule: string;
+            severity: "error" | "warning" | "info";
+            message: string;
+        }>;
+    }>;
+};
+
+async function lintAndAnnotateExport(options: {
+    path: string;
+    from: string;
+    to: string;
+    cwd: string;
+    json: boolean;
+    errorsOnly: boolean;
+    reportTitle: string;
+}): Promise<number> {
+    const native = loadNiftyNative();
+    const report = native.lint.run({
+        cwd: options.cwd,
+        fromRef: options.from,
+        toRef: options.to,
+        commitOnly: true,
+        scanCargo: false,
+    });
+    const diagnostics = options.errorsOnly
+        ? report.diagnostics.filter((item) => item.severity === "error")
+        : report.diagnostics;
+
+    if (options.json) {
+        const { printCommitLintReport } = await import("./commit-lint-report.js");
+        printCommitLintReport(diagnostics, report.errorCount, report.warningCount, {
+            json: true,
+            errorsOnly: options.errorsOnly,
+            title: options.reportTitle,
+        });
+    } else {
+        const { printCommitLintReport } = await import("./commit-lint-report.js");
+        printCommitLintReport(diagnostics, report.errorCount, report.warningCount, {
+            errorsOnly: options.errorsOnly,
+            title: options.reportTitle,
+        });
+    }
+
+    const byHash = new Map<string, Array<{ rule: string; severity: "error" | "warning" | "info"; message: string }>>();
+    for (const item of diagnostics) {
+        if (!item.hash) {
+            continue;
+        }
+        const bucket = byHash.get(item.hash) ?? [];
+        bucket.push({ rule: item.rule, severity: item.severity, message: item.message });
+        byHash.set(item.hash, bucket);
+    }
+
+    const text = await readFile(options.path, "utf8");
+    const document = JSON.parse(text) as ExportDocument;
+    document.entries = document.entries.map((entry) => {
+        const violations = byHash.get(entry.hash);
+        if (!violations || violations.length === 0) {
+            return entry;
+        }
+        return { ...entry, violations };
+    });
+    await writeFile(options.path, `${JSON.stringify(document, null, 2)}\n`, "utf8");
+    const violationCount = document.entries.filter((entry) => entry.violations && entry.violations.length > 0).length;
+    console.log(`export: annotated ${violationCount} commit entry(ies) with lint violations in ${options.path}`);
+    return report.errorCount;
+}
+
+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/commit-lint-report.ts

@@ -0,0 +1,110 @@
+export type CommitLintDiagnostic = {
+    rule: string;
+    severity: "error" | "warning" | "info";
+    message: string;
+    subject?: string;
+    hash?: string;
+    path?: string;
+    line?: number;
+};
+
+export type CommitLintReportOptions = {
+    json?: boolean;
+    errorsOnly?: boolean;
+    title?: string;
+};
+
+type CommitLintGroup = {
+    hash?: string;
+    subject?: string;
+    items: CommitLintDiagnostic[];
+};
+
+export function printCommitLintReport(
+    diagnostics: CommitLintDiagnostic[],
+    errorCount: number,
+    warningCount: number,
+    options: CommitLintReportOptions = {},
+): void {
+    const filtered = options.errorsOnly
+        ? diagnostics.filter((item) => item.severity === "error")
+        : diagnostics;
+
+    if (options.json) {
+        const payload = {
+            errorCount,
+            warningCount,
+            diagnostics: filtered,
+            groups: groupCommitDiagnostics(filtered),
+            summaryByRule: summarizeByRule(filtered),
+        };
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+
+    const title = options.title ?? "commit lint";
+    if (filtered.length === 0) {
+        console.log(`${title}: no issues found`);
+        return;
+    }
+
+    const groups = groupCommitDiagnostics(filtered);
+    const commitCount = groups.filter((group) => group.hash || group.subject).length;
+    console.log(`${title}: ${errorCount} error(s), ${warningCount} warning(s) in ${commitCount} commit(s)\n`);
+
+    for (const group of groups) {
+        printCommitGroup(group);
+    }
+
+    const summary = summarizeByRule(filtered.filter((item) => item.severity === "error"));
+    if (summary.length > 0) {
+        console.log("summary by rule:");
+        for (const [rule, count] of summary) {
+            console.log(`  ${rule}  ${count}`);
+        }
+        console.log();
+    }
+}
+
+function groupCommitDiagnostics(diagnostics: CommitLintDiagnostic[]): CommitLintGroup[] {
+    const groups = new Map<string, CommitLintGroup>();
+    const order: string[] = [];
+
+    for (const item of diagnostics) {
+        const key = item.hash ?? item.subject ?? "__inline__";
+        if (!groups.has(key)) {
+            groups.set(key, {
+                hash: item.hash,
+                subject: item.subject,
+                items: [],
+            });
+            order.push(key);
+        }
+        groups.get(key)?.items.push(item);
+    }
+
+    return order.map((key) => groups.get(key)!);
+}
+
+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]));
+}
+
+function printCommitGroup(group: CommitLintGroup): void {
+    if (group.hash || group.subject) {
+        const hash = group.hash ? `${group.hash.slice(0, 8)}  ` : "";
+        const subject = group.subject ?? "(no subject)";
+        console.log(`${hash}${subject}`);
+    } else {
+        console.log("(inline subject lint)");
+    }
+
+    for (const item of group.items) {
+        console.log(`  ${item.severity}  ${item.rule}  ${item.message}`);
+    }
+    console.log();
+}

package/src/cli/format.ts

@@ -1,3 +1,4 @@
+import { loadConfig, resolveFormatConfig } from "../config/index.js";
 import { loadNiftyNative } from "../native.js";
 
 export type FormatOptions = {
@@ -6,10 +7,18 @@ export type FormatOptions = {
 };
 
 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);
     const native = loadNiftyNative();
     const report = native.formatter.run({
-        cwd: options.cwd,
+        cwd,
         check: options.check,
+        includes: resolved.includes,
+        excludes: resolved.excludes,
+        rust: resolved.rust,
+        javascript: resolved.javascript,
+        style: resolved.style,
     });
 
     if (report.errors.length > 0) {
@@ -19,9 +28,11 @@ export async function formatWorkspace(options: FormatOptions): Promise<number> {
     }
 
     if (report.formatted === 0 && report.unchanged > 0 && report.errors.length === 0) {
-        console.log("format: no changes needed");
+        console.log(`format: no changes needed (preset ${resolved.preset})`);
     } else if (report.errors.length === 0) {
-        console.log(`format: ${report.formatted} file(s) updated, ${report.unchanged} unchanged`);
+        console.log(
+            `format: ${report.formatted} file(s) updated, ${report.unchanged} unchanged (preset ${resolved.preset})`,
+        );
     }
 
     return report.errors.length > 0 ? 1 : 0;

package/src/cli/lint.ts

@@ -1,5 +1,6 @@
 import { loadConfig } from "../config/loadConfig.js";
 import { loadNiftyNative } from "../native.js";
+import { printCommitLintReport, type CommitLintDiagnostic } from "./commit-lint-report.js";
 
 export type LintOptions = {
     subjects: string[];
@@ -7,17 +8,13 @@ export type LintOptions = {
     to?: string;
     cwd?: string;
     scanCargo?: boolean;
+    commitOnly?: boolean;
+    json?: boolean;
+    errorsOnly?: boolean;
+    reportTitle?: string;
 };
 
-type LintDiagnostic = {
-    rule: string;
-    severity: "error" | "warning" | "info";
-    message: string;
-    subject?: string;
-    hash?: string;
-    path?: string;
-    line?: number;
-};
+type LintDiagnostic = CommitLintDiagnostic;
 
 type LintRuleConfig = {
     id: string;
@@ -33,7 +30,11 @@ export async function runLint(argv: string[], check: boolean): Promise<void> {
     }
 }
 
-export async function lintCommits(options: LintOptions, check: boolean): Promise<number> {
+export async function lintCommits(
+    options: LintOptions,
+    check: boolean,
+    commitOnly = options.commitOnly ?? false,
+): Promise<number> {
     const native = loadNiftyNative();
     const cwd = options.cwd ?? process.cwd();
     const { config } = await loadConfig({ cwd, createIfMissing: false });
@@ -51,25 +52,35 @@ export async function lintCommits(options: LintOptions, check: boolean): Promise
         subjects: options.subjects.length > 0 ? options.subjects : undefined,
         rules,
         scanCargo: options.scanCargo,
+        commitOnly: commitOnly || options.commitOnly,
     });
 
-    for (const item of report.diagnostics) {
-        printDiagnostic(item);
-    }
-
-    if (report.diagnostics.length > 0) {
-        console.log(`lint: ${report.errorCount} error(s), ${report.warningCount} warning(s)`);
+    if (commitOnly || options.commitOnly) {
+        printCommitLintReport(report.diagnostics, report.errorCount, report.warningCount, {
+            json: options.json,
+            errorsOnly: options.errorsOnly,
+            title: options.reportTitle ?? "commit lint",
+        });
     } else {
-        console.log("lint: no issues found");
+        for (const item of report.diagnostics) {
+            printWorkspaceDiagnostic(item);
+        }
+
+        if (report.diagnostics.length > 0) {
+            console.log(`lint: ${report.errorCount} error(s), ${report.warningCount} warning(s)`);
+        } else {
+            console.log("lint: no issues found");
+        }
     }
 
     return report.errorCount;
 }
 
-function printDiagnostic(item: LintDiagnostic): void {
+function printWorkspaceDiagnostic(item: LintDiagnostic): void {
     const prefix = item.severity === "error" ? "error" : item.severity === "warning" ? "warning" : "info";
     if (item.subject) {
-        console.log(`${prefix} [${item.rule}] ${item.message} (${item.subject})`);
+        const hash = item.hash ? `${item.hash.slice(0, 8)} ` : "";
+        console.log(`${prefix} [${item.rule}] ${hash}${item.message} (${item.subject})`);
         return;
     }
     const location =

package/src/config/authorMap.ts

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+
+import type { NiftyConfig } from "./types.js";
+
+/** Default path relative to repo root (email → GitHub author JSON). */
+export const DEFAULT_AUTHOR_MAP_PATH = "documentation/maintenance/author-github.json";
+
+/** Resolve configured author map path to an absolute filesystem path. */
+export function resolveAuthorMapPath(config: NiftyConfig, repoRoot: string): string {
+    const configured = config.authorMap ?? DEFAULT_AUTHOR_MAP_PATH;
+    return isAbsolute(configured) ? configured : join(repoRoot, configured);
+}
+
+/** Load author map file contents for native helpers expecting JSON text. */
+export function loadAuthorMapJson(repoRoot: string, authorMapPath?: string): string {
+    const abs = authorMapPath
+        ? isAbsolute(authorMapPath)
+            ? authorMapPath
+            : join(repoRoot, authorMapPath)
+        : resolveAuthorMapPath({}, repoRoot);
+    if (!existsSync(abs)) {
+        return "{}";
+    }
+    return readFileSync(abs, "utf8");
+}

package/src/config/formatPresets.ts

@@ -0,0 +1,64 @@
+import type { NiftyFormatConfig, NiftyFormatPreset, NiftyFormatStyleConfig } from "./types.js";
+
+export type ResolvedFormatOptions = {
+    preset: NiftyFormatPreset;
+    includes?: string[];
+    excludes?: string[];
+    rust?: boolean;
+    javascript?: boolean;
+    style: NiftyFormatStyleConfig;
+};
+
+const DEFAULT_FORMAT_STYLE: NiftyFormatStyleConfig = {
+    indentStyle: "space",
+    indentWidth: 4,
+    lineWidth: 144,
+    quoteStyle: "single",
+};
+
+const NIFTY_PRESET_INCLUDES = [
+    "scripts/**",
+    "projects/packages/**",
+    "projects/conformance/**",
+    "projects/dashboard/**",
+    "package.json",
+    "nifty.config.ts",
+] as const;
+
+/** VMZ hybrid monorepo — JS/TS surfaces only, never whole-repo walk. */
+const VMZ_INCLUDES = [
+    "scripts/**",
+    "packages/runtimes/**",
+    "packages/examples/**",
+    "packages/editors/**",
+    "packages/ui/**",
+    "packages/plugins/**",
+    "packages/content/**",
+    "packages/homepage/**",
+    "package.json",
+    "nifty.config.ts",
+] as const;
+
+const PRESET_INCLUDES: Record<NiftyFormatPreset, readonly string[] | undefined> = {
+    default: undefined,
+    nifty: NIFTY_PRESET_INCLUDES,
+    "npm-tools": NIFTY_PRESET_INCLUDES,
+    vmz: VMZ_INCLUDES,
+};
+
+/** Merge `nifty.config` `format` with built-in preset defaults. */
+export function resolveFormatConfig(format: NiftyFormatConfig | undefined): ResolvedFormatOptions {
+    const preset = format?.preset ?? "default";
+    const presetIncludes = PRESET_INCLUDES[preset];
+    return {
+        preset,
+        includes: format?.includes ?? (presetIncludes ? [...presetIncludes] : undefined),
+        excludes: format?.excludes,
+        rust: format?.rust,
+        javascript: format?.javascript,
+        style: {
+            ...DEFAULT_FORMAT_STYLE,
+            ...format?.style,
+        },
+    };
+}

package/src/config/index.ts

@@ -8,7 +8,11 @@ export {
     type ProjectLayout,
 } from "./detectProject.js";
 export {
-    authorMapToJson,
+    DEFAULT_AUTHOR_MAP_PATH,
+    loadAuthorMapJson,
+    resolveAuthorMapPath,
+} from "./authorMap.js";
+export {
     defaultConfigPath,
     ensureConfigFile,
     findConfigFile,
@@ -16,10 +20,14 @@ export {
     type LoadConfigOptions,
     type LoadedNiftyConfig,
 } from "./loadConfig.js";
+export { resolveFormatConfig, type ResolvedFormatOptions } from "./formatPresets.js";
 export {
     CONFIG_FILE_NAMES,
     type NiftyAuthorEntry,
     type NiftyConfig,
     type NiftyConfigEnv,
     type NiftyConfigExport,
+    type NiftyFormatConfig,
+    type NiftyFormatPreset,
+    type NiftyFormatStyleConfig,
 } from "./types.js";

package/src/config/loadConfig.ts

@@ -28,7 +28,7 @@ export type LoadedNiftyConfig = {
 };
 
 const DEFAULT_CONFIG_TEMPLATE = `// Nifty project configuration.
-// See @doki-land/nifty for defineConfig, githubToken, authorMap, and lint rules.
+// See @doki-land/nifty for defineConfig, format presets, authorMap path, and lint rules.
 export default {};
 `;
 
@@ -120,10 +120,3 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Loade
     return { config, configFile, created };
 }
 
-/** Serialize `authorMap` for native helpers expecting JSON text. */
-export function authorMapToJson(authorMap: NiftyConfig["authorMap"]): string {
-    if (!authorMap || Object.keys(authorMap).length === 0) {
-        return "{}";
-    }
-    return JSON.stringify(authorMap);
-}

package/src/config/types.ts

@@ -1,15 +1,46 @@
-/** GitHub author entry in `authorMap` (same shape as `author-github.json`). */
+/** One email → GitHub author row in `author-github.json`. */
 export type NiftyAuthorEntry = {
     id?: number;
     login?: string;
 };
 
+/** Built-in workspace format presets (`nifty.config` `format.preset`). */
+export type NiftyFormatPreset = "default" | "nifty" | "npm-tools" | "vmz";
+
+/** `oxc_formatter` style knobs (`nifty.config` `format.style`). */
+export type NiftyFormatStyleConfig = {
+    /** Indent with spaces or tabs (default: `space`). */
+    indentStyle?: "space" | "tab";
+    /** Spaces or tabs per indent level (default: `4`). */
+    indentWidth?: number;
+    /** Soft line width (default: `144`). */
+    lineWidth?: number;
+    /** String quote preference (default: `single`). */
+    quoteStyle?: "single" | "double";
+};
+
+/** Workspace format options (`nifty format` reads `nifty.config` `format`). */
+export type NiftyFormatConfig = {
+    /** Select built-in include roots for Nifty hybrid monorepos. */
+    preset?: NiftyFormatPreset;
+    /** Extra include globs (override preset list when set alone). */
+    includes?: string[];
+    /** Skip paths under these globs after includes expand. */
+    excludes?: string[];
+    /** Run `cargo fmt` (default: true when a Cargo workspace is detected). */
+    rust?: boolean;
+    /** Run `oxc_formatter` on JS/TS targets (default: true). */
+    javascript?: boolean;
+    /** Inline oxc formatter style (not an external config file path). */
+    style?: NiftyFormatStyleConfig;
+};
+
 /** Nifty project configuration (`nifty.config.ts` / `nifty.config.js`). */
 export type NiftyConfig = {
     /** GitHub personal access token for email search / profile fetch. */
     githubToken?: string;
-    /** Email → GitHub author mapping. */
-    authorMap?: Record<string, NiftyAuthorEntry>;
+    /** Path to `author-github.json` (default: `documentation/maintenance/author-github.json`). */
+    authorMap?: string;
     /** Repository root override when discovering git metadata. */
     repoRoot?: string;
     /** Cargo workspace / crate root override. */
@@ -25,8 +56,6 @@ export type NiftyConfig = {
     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;
     };
@@ -38,6 +67,8 @@ export type NiftyConfig = {
             severity?: "error" | "warning" | "info";
         }>;
     };
+    /** Workspace format targets and engines (`nifty format`). */
+    format?: NiftyFormatConfig;
 };
 
 export type NiftyConfigExport = NiftyConfig | ((env: NiftyConfigEnv) => NiftyConfig | Promise<NiftyConfig>);

package/src/index.ts

@@ -21,16 +21,23 @@ export {
     defineConfig,
     loadConfig,
     findConfigFile,
-    authorMapToJson,
+    DEFAULT_AUTHOR_MAP_PATH,
+    loadAuthorMapJson,
+    resolveAuthorMapPath,
     detectProjectLayout,
     discoverPackageDirs,
     findCargoManifest,
     findPackageManifest,
     type LoadConfigOptions,
     type LoadedNiftyConfig,
+    resolveFormatConfig,
     type NiftyAuthorEntry,
     type NiftyConfig,
     type NiftyConfigEnv,
+    type NiftyFormatConfig,
+    type NiftyFormatPreset,
+    type NiftyFormatStyleConfig,
     type ProjectKind,
     type ProjectLayout,
+    type ResolvedFormatOptions,
 } from "./config/index.js";

package/src/native.ts

@@ -85,12 +85,27 @@ export type RewordRewriteReport = {
 };
 
 export type HistoryExports = {
+    "commit-export": (options: {
+        cwd?: string;
+        base: string;
+        ref?: string;
+        path: string;
+    }) => { count: number; path: string };
+    "commit-apply": (options: {
+        cwd?: string;
+        base: string;
+        ref?: string;
+        path: string;
+        dryRun?: boolean;
+    }) => RewordRewriteReport;
+    /** @deprecated use `commit-export` */
     "reword-export": (options: {
         cwd?: string;
         base: string;
         ref?: string;
         path: string;
     }) => { count: number; path: string };
+    /** @deprecated use `commit-apply` */
     "reword-rewrite": (options: {
         cwd?: string;
         base: string;
@@ -160,6 +175,7 @@ export type LintRunOptions = {
     subjects?: string[];
     rules?: Array<{ id: string; enabled?: boolean; severity?: "error" | "warning" | "info" }>;
     scanCargo?: boolean;
+    commitOnly?: boolean;
 };
 
 export type LintReportRecord = {
@@ -183,8 +199,25 @@ export type FormatReportRecord = {
     errors: string[];
 };
 
+export type FormatterStyleOptions = {
+    indentStyle?: string;
+    indentWidth?: number;
+    lineWidth?: number;
+    quoteStyle?: string;
+};
+
+export type FormatterRunOptions = {
+    cwd?: string;
+    check?: boolean;
+    includes?: string[];
+    excludes?: string[];
+    rust?: boolean;
+    javascript?: boolean;
+    style?: FormatterStyleOptions;
+};
+
 export type FormatterExports = {
-    run: (options: { cwd?: string; check?: boolean }) => FormatReportRecord;
+    run: (options: FormatterRunOptions) => FormatReportRecord;
 };
 
 export type PublisherExports = {
@@ -280,6 +313,31 @@ type NativeBinding = {
         totpSecret?: string | null;
         token?: string | null;
     }) => TrustReport;
+    gitToolsCommitExport: (options: {
+        cwd?: string | null;
+        base: string;
+        ref?: string | null;
+        path: string;
+    }) => { count: number; path: string };
+    gitToolsCommitApply: (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;
+    };
     gitToolsRewordExport: (options: {
         cwd?: string | null;
         base: string;
@@ -355,6 +413,7 @@ type NativeBinding = {
         subjects?: string[] | null;
         rules?: Array<{ id: string; enabled?: boolean | null; severity?: string | null }> | null;
         scanCargo?: boolean | null;
+        commitOnly?: boolean | null;
         check?: boolean | null;
     }) => {
         diagnostics: Array<{
@@ -376,6 +435,7 @@ type NativeBinding = {
         subjects?: string[] | null;
         rules?: Array<{ id: string; enabled?: boolean | null; severity?: string | null }> | null;
         scanCargo?: boolean | null;
+        commitOnly?: boolean | null;
         check?: boolean | null;
     }) => {
         diagnostics: Array<{
@@ -391,7 +451,15 @@ type NativeBinding = {
         warningCount: number;
     };
     updaterRun: (options: { cwd?: string | null; interactive?: boolean | null }) => void;
-    formatterRun: (options: { cwd?: string | null; check?: boolean | null }) => {
+    formatterRun: (options: {
+        cwd?: string | null;
+        check?: boolean | null;
+        includes?: string[] | null;
+        excludes?: string[] | null;
+        rust?: boolean | null;
+        javascript?: boolean | null;
+        style?: FormatterStyleOptions | null;
+    }) => {
         formatted: number;
         unchanged: number;
         errors: string[];
@@ -424,6 +492,7 @@ function mapLintOptions(options: LintRunOptions) {
         ...(options.subjects !== undefined ? { subjects: options.subjects } : {}),
         ...(options.rules !== undefined ? { rules: options.rules } : {}),
         ...(options.scanCargo !== undefined ? { scanCargo: options.scanCargo } : {}),
+        ...(options.commitOnly !== undefined ? { commitOnly: options.commitOnly } : {}),
     };
 }
 
@@ -498,6 +567,29 @@ function wrapBinding(binding: NativeBinding): NiftyNative {
             "parse-github-remote": (url) => binding.gitParseGithubRemote(url) ?? undefined,
         },
         history: {
+            "commit-export": (options) =>
+                binding.gitToolsCommitExport({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    base: options.base,
+                    ...(options.ref !== undefined ? { ref: options.ref } : {}),
+                    path: options.path,
+                }),
+            "commit-apply": (options) => {
+                const report = binding.gitToolsCommitApply({
+                    ...(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,
+                };
+            },
             "reword-export": (options) =>
                 binding.gitToolsRewordExport({
                     ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
@@ -586,10 +678,16 @@ function wrapBinding(binding: NativeBinding): NiftyNative {
             },
         },
         formatter: {
-            run: (options) => binding.formatterRun({
-                ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
-                ...(options.check !== undefined ? { check: options.check } : {}),
-            }),
+            run: (options) =>
+                binding.formatterRun({
+                    ...(options.cwd !== undefined ? { cwd: options.cwd } : {}),
+                    ...(options.check !== undefined ? { check: options.check } : {}),
+                    ...(options.includes !== undefined ? { includes: options.includes } : {}),
+                    ...(options.excludes !== undefined ? { excludes: options.excludes } : {}),
+                    ...(options.rust !== undefined ? { rust: options.rust } : {}),
+                    ...(options.javascript !== undefined ? { javascript: options.javascript } : {}),
+                    ...(options.style !== undefined ? { style: options.style } : {}),
+                }),
         },
         publisher: {
             "publish-workspace": (options) =>

package/src/nifty.ts

@@ -1,6 +1,6 @@
 import {
-    authorMapToJson,
     detectProjectLayout,
+    loadAuthorMapJson,
     loadConfig,
     type LoadConfigOptions,
     type NiftyConfig,
@@ -79,8 +79,9 @@ export class Nifty {
         );
 
         const native = loadNiftyNative();
+        const resolvedRepoRoot = merged.repoRoot ?? layout.root;
         return new Nifty(
-            new Gitmoji(native.gitmoji, authorMapToJson(merged.authorMap)),
+            new Gitmoji(native.gitmoji, loadAuthorMapJson(resolvedRepoRoot, merged.authorMap)),
             new Git(native.git),
             Github.open(merged.githubToken),
             merged,

package/src/cli/reword-cmd.ts

@@ -1,87 +0,0 @@
-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;
-}