@doki-land/nifty 0.1.1 → 0.1.2

package/src/cli/commit-cmd.ts

@@ -7,7 +7,7 @@ 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 {
+export function registerCommitCommand(cli: Cli): void {
     const commit = cli.command("commit", "cli.cmd.commit");
 
     commit
@@ -17,7 +17,7 @@ export function registerCommitCommand(cli : Cli) : void {
         .option("--path <file>", "cli.opt.path")
         .option("--with-lint", "cli.opt.with-lint")
         .option("--errors-only", "cli.opt.errors-only")
-        .action(async(options) =>cmdCommitExport(options));
+        .action(async(options) => cmdCommitExport(options));
 
     commit
         .command("apply", "cli.cmd.commit.apply")
@@ -25,7 +25,7 @@ export function registerCommitCommand(cli : Cli) : void {
         .option("--ref <ref>", "cli.opt.ref")
         .option("--path <file>", "cli.opt.path")
         .option("--dry-run", "cli.opt.dry-run")
-        .action(async(options) =>cmdCommitApply(options));
+        .action(async(options) => cmdCommitApply(options));
 
     commit
         .command("scan", "cli.cmd.commit.scan")
@@ -34,7 +34,7 @@ export function registerCommitCommand(cli : Cli) : void {
         .option("-s, --subject <text>...", "cli.opt.subject")
         .option("--json", "cli.opt.json")
         .option("--errors-only", "cli.opt.errors-only")
-        .action(async(options) =>cmdCommitScan(options));
+        .action(async(options) => cmdCommitScan(options));
 
     commit
         .command("audit", "cli.cmd.commit.audit")
@@ -43,33 +43,33 @@ export function registerCommitCommand(cli : Cli) : void {
         .option("-s, --subject <text>...", "cli.opt.subject")
         .option("--json", "cli.opt.json")
         .option("--errors-only", "cli.opt.errors-only")
-        .action(async(options) =>cmdCommitAudit(options));
+        .action(async(options) => cmdCommitAudit(options));
 }
 
-export async function cmdCommitExport(options : ParsedOptions) : Promise<number>{
+export async function cmdCommitExport(options: ParsedOptions): Promise < number> {
     await bootstrapFromOptions(options);
     const base = requireStr(options, "base");
     const path = str(options, "path") ?? "commit.pending.json";
     const native = loadNiftyNative();
     const report = native.history["commit-export"]({
-        cwd : cwdFrom(options),
+        cwd: cwdFrom(options),
         base,
-        ref : str(options, "ref"),
+        ref: str(options, "ref"),
         path,
     });
     console.log(`export: wrote ${report.count} commit entry(ies) to ${report.path}`);
 
-    if(flag(options, "with-lint")){
+    if (flag(options, "with-lint")) {
         const errorCount = await lintAndAnnotateExport({
             path,
-            from : base,
-            to : str(options, "ref") ?? "HEAD",
-            cwd : cwdFrom(options) ?? process.cwd(),
-            json : flag(options, "json"),
-            errorsOnly : flag(options, "errors-only"),
-            reportTitle : "commit export lint",
+            from: base,
+            to: str(options, "ref") ?? "HEAD",
+            cwd: cwdFrom(options) ?? process.cwd(),
+            json: flag(options, "json"),
+            errorsOnly: flag(options, "errors-only"),
+            reportTitle: "commit export lint",
         });
-        if(errorCount>0){
+        if (errorCount > 0) {
             return 1;
         }
     }
@@ -77,30 +77,30 @@ export async function cmdCommitExport(options : ParsedOptions) : Promise<number>
     return 0;
 }
 
-export async function cmdCommitApply(options : ParsedOptions) : Promise<number>{
+export async function cmdCommitApply(options: ParsedOptions): Promise < number> {
     await bootstrapFromOptions(options);
     const base = requireStr(options, "base");
     const path = requireStr(options, "path");
     const dryRun = flag(options, "dry-run");
     const native = loadNiftyNative();
     const report = native.history["commit-apply"]({
-        cwd : cwdFrom(options),
+        cwd: cwdFrom(options),
         base,
-        ref : str(options, "ref"),
+        ref: str(options, "ref"),
         path,
         dryRun,
     });
 
-    if(dryRun){
-        if(report.changes.length === 0){
+    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){
+        for (const change of report.changes) {
             console.log(`${change.oldOid}  ${change.oldSubject}`);
             console.log(`     ->  ${change.newSubject}`);
-            if(change.parentsRelinked && !change.messageChanged){
+            if (change.parentsRelinked && !change.messageChanged) {
                 console.log("     (parent chain relink only)");
             }
             console.log();
@@ -111,115 +111,113 @@ export async function cmdCommitApply(options : ParsedOptions) : Promise<number>{
     console.log(
         `applied ${report.changes.length} commit object(s); ${report.oldTip} -> ${report.newTip ?? report.oldTip}`,
     );
-    for(const change of report.changes){
+    for (const change of report.changes) {
         console.log(`  ${change.oldOid}  ${change.newSubject}`);
     }
     return 0;
 }
 
-export async function cmdCommitScan(options : ParsedOptions) : Promise<number>{
+export async function cmdCommitScan(options: ParsedOptions): Promise < number> {
     await bootstrapFromOptions(options);
-    await lintCommits({ ...commitLintOptions(options), reportTitle : "commit scan" }, false, true);
+    await lintCommits({ ...commitLintOptions(options), reportTitle: "commit scan" }, false, true);
     return 0;
 }
 
-export async function cmdCommitAudit(options : ParsedOptions) : Promise<number>{
+export async function cmdCommitAudit(options: ParsedOptions): Promise < number> {
     await bootstrapFromOptions(options);
     const errorCount = await lintCommits(commitLintOptions(options), false, true);
-    return errorCount>0 ? 1 : 0;
+    return errorCount > 0 ? 1 : 0;
 }
 
-function commitLintOptions(options : ParsedOptions) : LintOptions {
+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",
+        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;
+    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>{
+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,
+        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;
+    const diagnostics = options.errorsOnly ? report.diagnostics.filter((item) => item.severity === "error") : report.diagnostics;
 
-    if(options.json){
+    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,
+            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,
+            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){
+    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 });
+        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) =>{
+    document.entries = document.entries.map((entry) => {
         const violations = byHash.get(entry.hash);
-        if(!violations || violations.length === 0){
+        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;
+    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 {
+function requireStr(options: ParsedOptions, key: string): string {
     const value = str(options, key);
-    if(!value){
+    if (!value) {
         throw new Error(`missing required --${key}`);
     }
     return value;

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

@@ -1,101 +1,99 @@
 export type CommitLintDiagnostic = {
-    rule : string;
-    severity : "error" | "warning" | "info";
-    message : string;
-    subject ? : string;
-    hash ? : string;
-    path ? : string;
-    line ? : number;
+    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;
+    json?: boolean;
+    errorsOnly?: boolean;
+    title?: string;
 };
 
 type CommitLintGroup = {
-    hash ? : string;
-    subject ? : string;
-    items : CommitLintDiagnostic[];
+    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;
+    diagnostics: CommitLintDiagnostic[],
+    errorCount: number,
+    warningCount: number,
+    options: CommitLintReportOptions = { },
+): void {
+    const filtered = options.errorsOnly ? diagnostics.filter((item) => item.severity === "error") : diagnostics;
 
-    if(options.json){
+    if (options.json) {
         const payload = {
             errorCount,
             warningCount,
-            diagnostics : filtered,
-            groups : groupCommitDiagnostics(filtered),
-            summaryByRule : summarizeByRule(filtered),
+            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){
+    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;
+    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){
+    for (const group of groups) {
         printCommitGroup(group);
     }
 
-    const summary = summarizeByRule(filtered.filter((item) =>item.severity === "error"));
-    if(summary.length>0){
+    const summary = summarizeByRule(filtered.filter((item) => item.severity === "error"));
+    if (summary.length > 0) {
         console.log("summary by rule:");
-        for(const[rule, count]of summary){
+        for (const[rule, count]of summary) {
             console.log(`  ${rule}  ${count}`);
         }
         console.log();
     }
 }
 
-function groupCommitDiagnostics(diagnostics : CommitLintDiagnostic[]) : CommitLintGroup[]{
-    const groups = new Map<string, CommitLintGroup>();
-    const order : string[] = [];
+function groupCommitDiagnostics(diagnostics: CommitLintDiagnostic[]): CommitLintGroup[] {
+    const groups = new Map < string, CommitLintGroup > ();
+    const order: string[] = [];
 
-    for(const item of diagnostics){
+    for (const item of diagnostics) {
         const key = item.hash ?? item.subject ?? "__inline__";
-        if(!groups.has(key)){
+        if (!groups.has(key)) {
             groups.set(key, {
-                hash : item.hash,
-                subject : item.subject,
-                items : [],
+                hash: item.hash,
+                subject: item.subject,
+                items: [],
             });
             order.push(key);
         }
-        groups.get(key) ?.items.push(item);
+        groups.get(key)?.items.push(item);
     }
 
-    return order.map((key) =>groups.get(key)!);
+    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){
+function summarizeByRule(diagnostics: CommitLintDiagnostic[]): Array < [string, number] > {
+    const counts = new Map < string, number > ();
+    for (const item of diagnostics) {
         counts.set(item.rule, (counts.get(item.rule) ?? 0) + 1);
     }
-    return[...counts.entries()].sort((left, right) =>right[1] - left[1] || left[0].localeCompare(right[0]));
+    return[...counts.entries()].sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
 }
 
-function printCommitGroup(group : CommitLintGroup) : void {
-    if(group.hash || group.subject){
+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}`);
@@ -103,7 +101,7 @@ function printCommitGroup(group : CommitLintGroup) : void {
         console.log("(inline subject lint)");
     }
 
-    for(const item of group.items){
+    for (const item of group.items) {
         console.log(`  ${item.severity}  ${item.rule}  ${item.message}`);
     }
     console.log();

package/src/cli/context.ts

@@ -6,16 +6,16 @@ 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 }{
+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){
+    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 = resolve(argv[ ++ i] ?? cwd);
+        } else if (arg === "-C" || arg === "--cwd") {
+            cwd = resolve(argv[++i] ?? cwd);
         }
     }
 
@@ -23,14 +23,14 @@ export function parseCliContext(argv : string[]) : { cwd : string; dryRun : bool
 }
 
 /** Ensure `nifty.config.*` exists before running a command (skip create on `--dry-run`). */
-export async function bootstrapNiftyConfig(argv : string[]) : Promise<void>{
+export async function bootstrapNiftyConfig(argv: string[]): Promise < void> {
     const { cwd, dryRun } = parseCliContext(argv);
-    await loadConfig({ cwd, createIfMissing : !dryRun });
+    await loadConfig({ cwd, createIfMissing: !dryRun });
 }
 
 /** Commander action hook: load config from parsed global/command flags. */
-export async function bootstrapFromOptions(options : ParsedOptions) : Promise<void>{
+export async function bootstrapFromOptions(options: ParsedOptions): Promise < void> {
     const cwd = cwdFrom(options) ?? process.cwd();
     const dryRun = options["dry-run"] === true;
-    await loadConfig({ cwd, createIfMissing : !dryRun });
+    await loadConfig({ cwd, createIfMissing: !dryRun });
 }

package/src/cli/format-cmd.ts

@@ -4,19 +4,19 @@ import { bootstrapFromOptions } from "./context.js";
 import { formatWorkspace } from "./format.js";
 import { cwdFrom, flag } from "./options.js";
 
-export function registerFormatCommand(cli : Cli) : void {
+export function registerFormatCommand(cli: Cli): void {
     cli.command("format", "cli.cmd.format")
         .option("--check", "cli.opt.check")
-        .action(async(options) =>cmdFormat(options));
+        .action(async(options) => cmdFormat(options));
 }
 
-export async function cmdFormat(options : ParsedOptions) : Promise<number>{
+export async function cmdFormat(options: ParsedOptions): Promise < number> {
     await bootstrapFromOptions(options);
     const exitCode = await formatWorkspace({
-        check : flag(options, "check"),
-        cwd : cwdFrom(options),
+        check: flag(options, "check"),
+        cwd: cwdFrom(options),
     });
-    if(exitCode!== 0){
+    if (exitCode !== 0) {
         throw new Error("format check failed");
     }
     return 0;

package/src/cli/format.ts

@@ -2,38 +2,38 @@ import { loadConfig, resolveFormatConfig } from "../config/index.js";
 import { loadNiftyNative } from "../native.js";
 
 export type FormatOptions = {
-    check ? : boolean;
-    cwd ? : string;
+    check?: boolean;
+    cwd?: string;
 };
 
-export async function formatWorkspace(options : FormatOptions) : Promise<number>{
+export async function formatWorkspace(options: FormatOptions): Promise < number> {
     const cwd = options.cwd ?? process.cwd();
-    const { config } = await loadConfig({ cwd, createIfMissing : false, env : { command : "format" } });
+    const { config } = await loadConfig({ cwd, createIfMissing: false, env: { command: "format" } });
     const resolved = resolveFormatConfig(config.format);
     const native = loadNiftyNative();
     const report = native.formatter.run({
         cwd,
-        check : options.check,
-        includes : resolved.includes,
-        excludes : resolved.excludes,
-        rust : resolved.rust,
-        javascript : resolved.javascript,
-        style : resolved.style,
+        check: options.check,
+        includes: resolved.includes,
+        excludes: resolved.excludes,
+        rust: resolved.rust,
+        javascript: resolved.javascript,
+        style: resolved.style,
     });
 
-    if(report.errors.length>0){
-        for(const message of report.errors){
+    if (report.errors.length > 0) {
+        for (const message of report.errors) {
             console.error(`error: ${message}`);
         }
     }
 
-    if(report.formatted === 0 && report.unchanged>0 && report.errors.length === 0){
+    if (report.formatted === 0 && report.unchanged > 0 && report.errors.length === 0) {
         console.log(`format: no changes needed (preset ${resolved.preset})`);
-    } else if(report.errors.length === 0){
+    } else if (report.errors.length === 0) {
         console.log(
             `format: ${report.formatted} file(s) updated, ${report.unchanged} unchanged (preset ${resolved.preset})`,
         );
     }
 
-    return report.errors.length>0 ? 1 : 0;
+    return report.errors.length > 0 ? 1 : 0;
 }

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

@@ -3,20 +3,20 @@ 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 {
+export function registerInstallNativeCommand(cli: Cli): void {
     cli.command("install-native", "cli.cmd.install-native")
         .option("--from <dir>", "cli.opt.from-artifacts")
-        .action(async(options) =>cmdInstallNative(options));
+        .action(async(options) => cmdInstallNative(options));
 }
 
-export async function cmdInstallNative(options : ParsedOptions) : Promise<number>{
+export async function cmdInstallNative(options: ParsedOptions): Promise < number> {
     const from =
         str(options, "from") ??
         process.env.NATIVE_ARTIFACT_ROOT ??
         "native-artifacts";
     installNativeFromOptions({
         from,
-        cwd : cwdFrom(options),
+        cwd: cwdFrom(options),
     });
     return 0;
 }