auklet 0.0.26 → 0.0.28

package/README.md

@@ -122,10 +122,28 @@ auklet CLI overrides.
 Publish controls stay on CLI flags:
 
 ```bash
+auk publish
 auk publish --filter @scope/ui
 auk publish --version patch --dry-run
 auk publish --no-format
 auk publish --otp 123456
+auk owner add alice
+auk owner add alice --filter @scope/ui --otp 123456
+```
+
+Target selection:
+
+```text
+auk publish
+├─ --filter <pattern>      publish matching workspace packages
+└─ no --filter             publish the current package
+   └─ private monorepo root -> fail; use --filter
+
+auk owner add <user...>
+├─ --filter <pattern>      add owners to matching workspace packages
+├─ --package <name>        add owners to explicit npm packages
+└─ no selector             add owners to the current package
+   └─ private package -> fail
 ```
 
 `--no-format` disables auklet's publish output formatter for that run. It is not
@@ -134,7 +152,8 @@ Before writing versions, auklet checks npm authentication from each target
 package directory. Package-local `.npmrc` files and
 `package.json#publishConfig.registry` are respected.
 `--otp` is forwarded to `pnpm publish` for npm accounts or organizations that
-require publish 2FA. In CI, prefer an npm automation token.
+require publish 2FA, and to `pnpm owner add` for owner management 2FA. In CI,
+prefer an npm automation token.
 
 ## Configuration
 

package/dist/publish/api/gitApi.js

@@ -10,7 +10,7 @@ export async function isGitRepository(cwd) {
     return !result.exitCode && result.stdout.trim() === 'true';
 }
 export async function getGitShortHash(cwd) {
-    const result = await runGit(['rev-parse', '--short=6', 'HEAD'], cwd);
+    const result = await runGit(['rev-parse', '--short=7', 'HEAD'], cwd);
     if (result.exitCode)
         return null;
     return result.stdout.trim() || null;

package/dist/publish/api/pnpmApi.d.ts

@@ -1,7 +1,11 @@
 import type { WorkspacePackage } from '#auklet/publish/types';
 export declare class NpmPublishAuthenticationError extends Error {
+    readonly packageRoot: string;
     constructor(packageRoot: string);
 }
+export declare class NpmPackageVersionExistsError extends Error {
+    constructor(packageName: string, version: string, registry?: string);
+}
 export declare function ensurePnpm(): Promise<string>;
 export declare function readPnpmWorkspacePackages(root: string): Promise<WorkspacePackage[]>;
 export declare function runPnpmBuild(packageRoot: string): Promise<void>;
@@ -10,6 +14,9 @@ export declare function runPnpmWhoami(packageRoot: string, options?: {
     packageName?: string;
     registry?: string;
 }): Promise<string>;
+export declare function hasPublishedPackageVersion(packageRoot: string, packageName: string, version: string, options?: {
+    registry?: string;
+}): Promise<boolean>;
 export declare function runPnpmOwnerAdd(packageName: string, user: string, options: {
     cwd: string;
     otp?: string;

package/dist/publish/api/pnpmApi.js

@@ -4,9 +4,16 @@ import semver from 'semver';
 import { readPnpmWorkspacePackageInfo } from '#auklet/workspace/packages';
 const supportedPnpmRange = '>=10.0.0';
 export class NpmPublishAuthenticationError extends Error {
+    packageRoot;
     constructor(packageRoot) {
-        super(`[publish] pnpm publish failed at ${packageRoot}: ` +
-            `npm publish requires additional authentication.`);
+        super('npm publish requires additional authentication.');
+        this.packageRoot = packageRoot;
+    }
+}
+export class NpmPackageVersionExistsError extends Error {
+    constructor(packageName, version, registry) {
+        const location = registry ? ` at ${registry}` : '';
+        super(`[publish] package ${packageName}@${version}${location} already exists.`);
     }
 }
 const runPnpm = async (args, options = {}) => {
@@ -64,7 +71,7 @@ export async function runPnpmPublish(packageRoot, args) {
         if (hasNpmAuthChallenge(result)) {
             throw new NpmPublishAuthenticationError(packageRoot);
         }
-        throw new Error(`[publish] pnpm publish failed at ${packageRoot}.`);
+        throw new Error('pnpm publish failed.');
     }
 }
 export async function runPnpmWhoami(packageRoot, options = {}) {
@@ -82,6 +89,19 @@ export async function runPnpmWhoami(packageRoot, options = {}) {
     }
     return String(result.stdout ?? '').trim();
 }
+export async function hasPublishedPackageVersion(packageRoot, packageName, version, options = {}) {
+    const args = ['view', `${packageName}@${version}`, 'version'];
+    if (options.registry)
+        args.push('--registry', options.registry);
+    const result = await runPnpm(args, {
+        cwd: packageRoot,
+    });
+    if (!result.exitCode)
+        return String(result.stdout ?? '').trim() === version;
+    if (isPackageNotFound(result))
+        return false;
+    throw new Error(`[publish] failed to check published version for ${packageName}@${version}.`);
+}
 export async function runPnpmOwnerAdd(packageName, user, options) {
     const args = ['owner', 'add', user, packageName];
     if (options.otp)
@@ -120,9 +140,12 @@ const writeProcessOutput = (result) => {
     const stdout = String(result.stdout ?? '');
     const stderr = String(result.stderr ?? '');
     if (stdout)
-        process.stdout.write(stdout);
+        process.stdout.write(withTrailingLineBreak(stdout));
     if (stderr)
-        process.stderr.write(stderr);
+        process.stderr.write(withTrailingLineBreak(stderr));
+};
+const withTrailingLineBreak = (value) => {
+    return value.endsWith('\n') ? value : `${value}\n`;
 };
 const isNpmAuthChallenge = (output) => {
     return [
@@ -133,3 +156,14 @@ const isNpmAuthChallenge = (output) => {
         'ENEEDAUTH',
     ].some((text) => output.includes(text));
 };
+const isPackageNotFound = (result) => {
+    const output = [result.stdout, result.stderr]
+        .map((value) => String(value ?? ''))
+        .join('\n');
+    return [
+        'E404',
+        '404 Not Found',
+        'is not in this registry',
+        'No match found for version',
+    ].some((text) => output.includes(text));
+};

package/dist/publish/api/publishHookApi.d.ts

@@ -3,8 +3,8 @@ type RunPublishHookOptions = {
     status: HookStatus;
     plan: PublishPlan;
     result?: HookResult;
-    failedTarget?: PublishTarget;
-    error?: unknown;
+    failedTarget?: PublishTarget | null;
+    error?: unknown | null;
 };
 export declare function runPublishHook(options: RunPublishHookOptions): Promise<void>;
 export {};

package/dist/publish/cli.js

@@ -36,8 +36,8 @@ export async function runPublishCli(args) {
         dryRun: argv['dry-run'] === true,
         format: argv.format !== false,
         otp: stringOption(argv.otp),
-        ignoreScripts: argv['ignore-scripts'] === true,
         allowDirty: argv['allow-dirty'] === true,
+        ignoreScripts: argv['ignore-scripts'] === true,
     }).run();
 }
 export async function runOwnerCli(args) {

package/dist/publish/publishRunner.d.ts

@@ -5,11 +5,9 @@ export declare class PublishRunner {
     private readonly preflight;
     private readonly versions;
     private readonly logger;
-    private readonly summaryLogger;
     private readonly options;
     constructor(options: PublishOptions);
     run(): Promise<void>;
-    private preparePlan;
     private publishWithPlan;
     private handleFailure;
     private runAfterPublishSuccess;

package/dist/publish/publishRunner.js

@@ -1,4 +1,4 @@
-import { createAukletLogger, createScopedAukletLogger } from '#auklet/logger';
+import { createScopedAukletLogger } from '#auklet/logger';
 import { runPublishHook } from '#auklet/publish/api/publishHookApi';
 import { runPackageBuilds, validateBuildScript, } from '#auklet/publish/runner/packageBuilder';
 import { formatPublishOutputs } from '#auklet/publish/runner/publishOutputFormatter';
@@ -16,21 +16,23 @@ export class PublishRunner {
     preflight;
     versions;
     logger;
-    summaryLogger;
     options;
     constructor(options) {
         this.options = options;
         this.logger = createScopedAukletLogger('publish');
-        this.summaryLogger = createAukletLogger();
         this.git = new ReleaseGitController(this.options, this.logger);
         this.publisher = new PackagePublisher(this.options, this.logger);
         this.preflight = new PublishPreflight(this.options, this.logger);
         this.versions = new VersionWriter(this.options, this.logger);
     }
     async run() {
-        const plan = await this.preparePlan();
+        const plan = await resolvePublishPlan(this.options, this.logger);
         let failureHookEnabled = false;
         try {
+            validateBuildScript(plan.targets);
+            await this.git.checkBeforePublish(plan);
+            await this.preflight.verifyBeforeBuild(plan);
+            this.versions.logDryRunPlan(plan);
             await runPublishHook({ status: 'beforeBuild', plan });
             failureHookEnabled = true;
             this.versions.writeBeforeBuild(plan);
@@ -42,7 +44,7 @@ export class PublishRunner {
         }
         catch (error) {
             if (!failureHookEnabled) {
-                reportPublishSummary(this.summaryLogger, {
+                reportPublishSummary({
                     plan,
                     status: 'failure',
                     error,
@@ -53,14 +55,6 @@ export class PublishRunner {
         }
         await this.runAfterPublishSuccess(plan);
     }
-    async preparePlan() {
-        const plan = await resolvePublishPlan(this.options, this.logger);
-        validateBuildScript(plan.targets);
-        await this.git.checkBeforePublish(plan);
-        await this.preflight.verifyAuthentication(plan);
-        this.versions.logDryRunPlan(plan);
-        return plan;
-    }
     async publishWithPlan(plan) {
         if (plan.dryRun) {
             await this.preflight.run(plan);
@@ -71,7 +65,7 @@ export class PublishRunner {
         await this.publisher.run(plan);
     }
     async handleFailure(plan, error) {
-        const failedTarget = error instanceof PublishTargetError ? error.target : undefined;
+        const failedTarget = error instanceof PublishTargetError ? error.target : null;
         try {
             await runPublishHook({
                 status: 'afterPublish',
@@ -85,9 +79,9 @@ export class PublishRunner {
             this.logger.error?.(hookError);
         }
         if (error instanceof PublishTargetError) {
-            reportPublishFailure(error, plan.version, this.logger);
+            reportPublishFailure(error, plan.version);
         }
-        reportPublishSummary(this.summaryLogger, {
+        reportPublishSummary({
             plan,
             status: 'failure',
             error,
@@ -101,9 +95,10 @@ export class PublishRunner {
             plan,
             result: 'success',
         });
-        reportPublishSummary(this.summaryLogger, {
+        reportPublishSummary({
             plan,
             status: 'success',
+            error: null,
         });
     }
 }

package/dist/publish/runner/packagePublisher.js

@@ -27,6 +27,6 @@ export function logAuthenticationError(logger, error) {
     if (!(error instanceof NpmPublishAuthenticationError))
         return;
     logger.error('npm publish requires additional authentication.');
-    logger.error('If publish 2FA is enabled, retry with `auk publish --otp <code>`.');
+    logger.error('If publish 2FA is enabled, retry with `--otp <code>`.');
     logger.error('For CI, use an npm automation token.');
 }

package/dist/publish/runner/publishFailureReporter.d.ts

@@ -1,3 +1,2 @@
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
-import type { AukletLogger } from '#auklet/logger';
-export declare function reportPublishFailure(error: PublishTargetError, version: string, logger: AukletLogger): void;
+export declare function reportPublishFailure(error: PublishTargetError, version: string): void;

package/dist/publish/runner/publishFailureReporter.js

@@ -1,14 +1,16 @@
-export function reportPublishFailure(error, version, logger) {
-    if (error.phase === 'publish' && error.publishedTargets.length) {
-        logger.error('partial publish detected');
-        logger.error('published packages:');
-        for (const target of error.publishedTargets) {
-            logger.error(formatPublishedTarget(logger, target.packageName, version));
-        }
-    }
-    logger.error('failed package:');
-    logger.error(formatPublishedTarget(logger, error.target.packageName, version));
+import { createAukletLogger } from '#auklet/logger';
+export function reportPublishFailure(error, version) {
+    const logger = createAukletLogger();
+    const noteBody = logger.colors.rgb(184, 140, 40);
+    const body = [
+        noteBody('  Some packages were already published before the failure.'),
+        '',
+        ...error.publishedTargets.map((target) => noteBody(`  published  ${target.packageName}@${version}`)),
+        noteBody(`  failed     ${error.target.packageName}@${version}`),
+    ];
+    logger.newline();
+    logger.note({
+        title: logger.colors.yellow(logger.colors.bold('Partial publish detected')),
+        body,
+    });
 }
-const formatPublishedTarget = (logger, packageName, version) => {
-    return ['- ', logger.package(packageName), '@', logger.version(version)];
-};

package/dist/publish/runner/publishPreflight.d.ts

@@ -6,6 +6,9 @@ export declare class PublishPreflight {
     private readonly pnpm;
     constructor(options: PublishOptions, logger: AukletLogger);
     run(plan: PublishPlan): Promise<void>;
-    verifyAuthentication(plan: PublishPlan): Promise<void>;
+    verifyBeforeBuild(plan: PublishPlan): Promise<void>;
+    private verifyAuthentication;
     private verifyPnpmPublishDryRun;
+    private verifyPackageVersions;
+    private logExistingVersion;
 }

package/dist/publish/runner/publishPreflight.js

@@ -1,6 +1,6 @@
 import { isPlainObject, isString } from 'aidly';
 import { PnpmPublishApi } from '#auklet/publish/api/pnpmPublishApi';
-import { runPnpmWhoami } from '#auklet/publish/api/pnpmApi';
+import { hasPublishedPackageVersion, NpmPackageVersionExistsError, runPnpmWhoami, } from '#auklet/publish/api/pnpmApi';
 import { logAuthenticationError } from '#auklet/publish/runner/packagePublisher';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
 export class PublishPreflight {
@@ -14,9 +14,13 @@ export class PublishPreflight {
     async run(plan) {
         await this.verifyPnpmPublishDryRun(plan);
     }
-    async verifyAuthentication(plan) {
+    async verifyBeforeBuild(plan) {
         if (plan.dryRun)
             return;
+        await this.verifyAuthentication(plan);
+        await this.verifyPackageVersions(plan);
+    }
+    async verifyAuthentication(plan) {
         const checked = new Set();
         for (const target of plan.targets) {
             const registry = getPublishRegistry(target.packageJson.publishConfig);
@@ -45,6 +49,22 @@ export class PublishPreflight {
             }
         }
     }
+    async verifyPackageVersions(plan) {
+        for (const target of plan.targets) {
+            const registry = getPublishRegistry(target.packageJson.publishConfig);
+            const exists = await hasPublishedPackageVersion(target.packageRoot, target.packageName, target.publishVersion, { registry });
+            if (!exists)
+                continue;
+            this.logExistingVersion(target, registry);
+            throw new PublishTargetError(target, 'preflight', new NpmPackageVersionExistsError(target.packageName, target.publishVersion, registry), []);
+        }
+    }
+    logExistingVersion(target, registry) {
+        this.logger.error('package version already exists: ', this.logger.package(target.packageName), '@', this.logger.version(target.publishVersion));
+        if (registry) {
+            this.logger.error('registry: ', this.logger.url(registry));
+        }
+    }
 }
 const getPublishRegistry = (publishConfig) => {
     if (!isPlainObject(publishConfig))

package/dist/publish/runner/publishSummaryReporter.d.ts

@@ -1,10 +1,30 @@
-import type { AukletLogger } from '#auklet/logger';
 import type { PublishPlan } from '#auklet/publish/types';
 type PublishSummaryStatus = 'success' | 'failure';
-type PublishSummaryOptions = {
+export type PublishSummaryOptions = {
     plan: PublishPlan;
     status: PublishSummaryStatus;
-    error?: unknown;
+    error: unknown | null;
 };
-export declare function reportPublishSummary(logger: AukletLogger, options: PublishSummaryOptions): void;
+export declare function reportPublishSummary(options: PublishSummaryOptions): void;
+export declare class PublishSummaryReporter {
+    private readonly options;
+    private readonly logger;
+    private publishedCount;
+    private failedTarget;
+    private publishError;
+    private publishedTargets;
+    private publishedTargetRoots;
+    constructor(options: PublishSummaryOptions);
+    report(): void;
+    private getSummaryTitle;
+    private getSummaryBody;
+    private getFailureReasonLine;
+    private getFailureMessage;
+    private getSummaryDetails;
+    private getVersionChangeTasks;
+    private getVersionChangeTaskStatus;
+    private getTargetKey;
+    private formatVersionChange;
+    private formatSummaryValue;
+}
 export {};

package/dist/publish/runner/publishSummaryReporter.js

@@ -1,85 +1,130 @@
+import { createAukletLogger } from '#auklet/logger';
 import { PublishTargetError } from '#auklet/publish/runner/publishTargetError';
-export function reportPublishSummary(logger, options) {
-    const publishError = options.error instanceof PublishTargetError ? options.error : undefined;
-    const failedTarget = publishError?.target;
-    const publishedTargets = publishError?.publishedTargets ?? [];
-    const publishedTargetRoots = new Set(publishedTargets.map((target) => getTargetKey(target)));
-    const publishedCount = options.status === 'success' && !options.plan.dryRun
-        ? options.plan.targets.length
-        : publishedTargets.length;
-    logger.newline();
-    logger.raw(logger.colors.gray('-'.repeat(56)));
-    logger.newline();
-    logger.result({
-        title: logger.colors.bold(getSummaryTitle(options.status, options.plan)),
-        status: options.status === 'success' ? 'success' : 'error',
-        body: getSummaryBody(options.status, options.plan, failedTarget),
-        details: {
-            mode: formatSummaryValue(logger, options.plan.dryRun ? 'dry-run' : 'publish'),
-            packages: formatSummaryValue(logger, options.plan.targets.length),
-            published: formatSummaryValue(logger, publishedCount),
-            version: logger.version(options.plan.version),
-        },
-    });
-    logger.newline();
-    logger.tasks({
-        tasks: getVersionChangeTasks(logger, {
-            targets: options.plan.targets,
-            status: options.status,
-            dryRun: options.plan.dryRun,
-            failedTarget,
-            publishedTargetRoots,
-        }),
-    });
-    logger.newline();
+export function reportPublishSummary(options) {
+    new PublishSummaryReporter(options).report();
 }
-const getSummaryTitle = (status, plan) => {
-    if (status === 'failure')
-        return 'Publish failed';
-    return plan.dryRun ? 'Publish dry-run complete' : 'Publish complete';
-};
-const getSummaryBody = (status, plan, failedTarget) => {
-    if (status === 'success') {
+export class PublishSummaryReporter {
+    options;
+    logger;
+    publishedCount = 0;
+    failedTarget;
+    publishError;
+    publishedTargets = [];
+    publishedTargetRoots = new Set();
+    constructor(options) {
+        this.options = options;
+        this.logger = createAukletLogger();
+        this.publishError =
+            options.error instanceof PublishTargetError ? options.error : null;
+        this.publishedTargets = this.publishError
+            ? this.publishError.publishedTargets
+            : [];
+        this.failedTarget = this.publishError ? this.publishError.target : null;
+        this.publishedTargetRoots = new Set(this.publishedTargets.map((target) => this.getTargetKey(target)));
+        this.publishedCount =
+            options.status === 'success' && !options.plan.dryRun
+                ? options.plan.targets.length
+                : this.publishedTargets.length;
+    }
+    report() {
+        this.logger.newline();
+        this.logger.raw(this.logger.colors.gray('-'.repeat(56)));
+        this.logger.newline();
+        this.logger.result({
+            title: this.logger.colors.bold(this.getSummaryTitle()),
+            status: this.options.status === 'success' ? 'success' : 'error',
+            body: this.getSummaryBody(),
+            details: this.getSummaryDetails(),
+        });
+        this.logger.newline();
+        this.logger.tasks({
+            tasks: this.getVersionChangeTasks(),
+        });
+        this.logger.newline();
+    }
+    getSummaryTitle() {
+        if (this.options.status === 'failure')
+            return 'Publish failed';
+        return this.options.plan.dryRun
+            ? 'Publish dry-run complete'
+            : 'Publish complete';
+    }
+    getSummaryBody() {
+        if (this.options.status === 'success') {
+            return [
+                this.options.plan.dryRun
+                    ? 'Preflight completed without publishing packages.'
+                    : 'All selected packages were published.',
+            ];
+        }
+        if (this.failedTarget) {
+            return [
+                ['Failed at ', this.logger.package(this.failedTarget.packageName), '.'],
+                ...this.getFailureReasonLine(),
+            ];
+        }
         return [
-            plan.dryRun
-                ? 'Preflight completed without publishing packages.'
-                : 'All selected packages were published.',
+            'Publish stopped before package publishing completed.',
+            ...this.getFailureReasonLine(),
         ];
     }
-    if (failedTarget) {
-        return [['Failed at ', failedTarget.packageName, '. Check logs above.']];
+    getFailureReasonLine() {
+        const message = this.getFailureMessage();
+        if (!message)
+            return [];
+        return [
+            [this.logger.colors.bold(this.logger.colors.red(`Reason: ${message}`))],
+        ];
+    }
+    getFailureMessage() {
+        const error = this.publishError
+            ? this.publishError.originalError
+            : this.options.error;
+        return error instanceof Error ? error.message : null;
+    }
+    getSummaryDetails() {
+        return {
+            mode: this.formatSummaryValue(this.options.plan.dryRun ? 'dry-run' : 'publish'),
+            packages: this.formatSummaryValue(this.options.plan.targets.length),
+            published: this.formatSummaryValue(this.publishedCount),
+            version: this.logger.version(this.options.plan.version),
+        };
     }
-    return ['Publish stopped before package publishing completed.'];
-};
-const getVersionChangeTasks = (logger, options) => {
-    return options.targets.map((target) => ({
-        title: [
-            logger.package(target.packageName),
-            ' ',
-            ...formatVersionChange(logger, target.version, target.publishVersion),
-        ],
-        status: getVersionChangeTaskStatus(target, options),
-    }));
-};
-const getVersionChangeTaskStatus = (target, options) => {
-    if (options.dryRun)
+    getVersionChangeTasks() {
+        return this.options.plan.targets.map((target) => ({
+            title: [
+                this.logger.package(target.packageName),
+                ' ',
+                ...this.formatVersionChange(target.version, target.publishVersion),
+            ],
+            status: this.getVersionChangeTaskStatus(target),
+        }));
+    }
+    getVersionChangeTaskStatus(target) {
+        if (this.options.plan.dryRun)
+            return 'skipped';
+        if (this.options.status === 'success')
+            return 'success';
+        if (this.failedTarget &&
+            this.getTargetKey(target) === this.getTargetKey(this.failedTarget)) {
+            return 'error';
+        }
+        if (this.publishedTargetRoots.has(this.getTargetKey(target))) {
+            return 'success';
+        }
         return 'skipped';
-    if (options.status === 'success')
-        return 'success';
-    if (options.failedTarget &&
-        getTargetKey(target) === getTargetKey(options.failedTarget)) {
-        return 'error';
     }
-    if (options.publishedTargetRoots.has(getTargetKey(target)))
-        return 'success';
-    return 'skipped';
-};
-const getTargetKey = (target) => {
-    return `${target.packageRoot}:${target.packageName}`;
-};
-const formatVersionChange = (logger, from, to) => {
-    return [logger.version(from), logger.colors.gray(' -> '), logger.version(to)];
-};
-const formatSummaryValue = (logger, value) => {
-    return logger.colors.bold(logger.colors.cyan(String(value)));
-};
+    getTargetKey(target) {
+        return `${target.packageRoot}:${target.packageName}`;
+    }
+    formatVersionChange(from, to) {
+        return [
+            this.logger.version(from),
+            this.logger.colors.gray(' -> '),
+            this.logger.version(to),
+        ];
+    }
+    formatSummaryValue(value) {
+        return this.logger.colors.bold(this.logger.colors.cyan(String(value)));
+    }
+}

package/dist/publish/runner/publishTargetError.js

@@ -5,7 +5,7 @@ export class PublishTargetError extends Error {
     originalError;
     publishedTargets;
     constructor(target, phase, originalError, publishedTargets) {
-        super(`[publish] ${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
+        super(`${phase} failed for ${target.packageName} at ${path.relative(process.cwd(), target.packageRoot) || target.packageRoot}.`);
         this.target = target;
         this.phase = phase;
         this.originalError = originalError;

package/dist/publish/runner/versionWriter.js

@@ -1,4 +1,5 @@
 import { readPackageJson, writePackageJson, } from '#auklet/publish/api/packageJsonApi';
+import { createAukletLogger } from '#auklet/logger';
 export class VersionWriter {
     options;
     logger;
@@ -48,7 +49,19 @@ export class VersionWriter {
     }
     logWrittenVersionFailure(plan) {
         if (!plan.dryRun && this.options.version) {
-            this.logger.error('package.json versions may have been written. Auklet will not roll them back; check publish output before retrying.');
+            const logger = createAukletLogger();
+            const noteBody = logger.colors.rgb(184, 140, 40);
+            logger.newline();
+            logger.note({
+                title: logger.colors.yellow(logger.colors.bold('Version files may have changed')),
+                body: [
+                    [noteBody('  package.json versions may have been written.')],
+                    [
+                        noteBody('  Auklet will not roll them back; check publish output before retrying.'),
+                    ],
+                ],
+            });
+            logger.newline();
         }
     }
     writeVersions(plan) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auklet",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "type": "module",
   "author": "chentao.arthur",
   "description": "Build utilities for TypeScript packages and module CSS output.",