@williamthorsen/release-kit 10.8.0 → 11.0.0

package/dist/esm/reportPrepare.js

@@ -1,6 +1,9 @@
+import { formatGlyphLine, formatStatusLine, measureGlyphColumn, STATUS_GLYPHS, truncateToWidth, } from '@williamthorsen/nmr-core';
 import { bold, dim, sectionHeader } from "./format.js";
+import { RELEASE_GLYPHS } from "./glyphs.js";
 import { GIT_CLIFF_NPX_ARGS } from "./runGitCliff.js";
 const CLIFF_DRY_RUN_COMMAND = `npx ${GIT_CLIFF_NPX_ARGS.join(' ')} ...`;
+const SUBJECT_COLUMN_BUDGET = 72;
 export function reportPrepare(plan, options) {
     const isMultiWorkspace = plan.workspaces.some((w) => w.name !== undefined) || plan.project !== undefined;
     if (isMultiWorkspace) {
@@ -10,6 +13,7 @@ export function reportPrepare(plan, options) {
 }
 function formatSingleWorkspace(result, options) {
     const dryRun = !options.applied;
+    const { style } = options;
     const lines = [];
     const workspace = result.workspaces[0];
     if (workspace === undefined) {
@@ -20,11 +24,11 @@ function formatSingleWorkspace(result, options) {
     if (workspace.parsedCommitCount !== undefined) {
         lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
     }
-    formatUnparseableWarning(lines, workspace);
-    formatPolicyViolations(lines, workspace.policyViolations);
+    formatUnparseableWarning(lines, workspace, style);
+    formatPolicyViolations(lines, workspace.policyViolations, style);
     if (workspace.status === 'skipped') {
-        lines.push(`⏭️  ${workspace.skipReason}`);
-        formatWarnings(lines, result);
+        lines.push(formatStatusLine(style, 'skipped', workspace.skipReason));
+        formatWarnings(lines, result, style);
         return lines.join('\n');
     }
     if (workspace.setVersion !== undefined) {
@@ -40,49 +44,50 @@ function formatSingleWorkspace(result, options) {
         lines.push(dim(`Bumping versions (version override)...`));
     }
     if (workspace.setVersion !== undefined) {
-        lines.push(`📦 ${workspace.currentVersion} → ${bold(workspace.newVersion)} (version override)`);
+        lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (version override)`));
     }
     else if (workspace.releaseType !== undefined) {
-        lines.push(`📦 ${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType})`);
+        lines.push(formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType})`));
     }
     formatBumpFiles(lines, workspace, dryRun);
     lines.push(dim('Generating changelogs...'));
     formatChangelogFiles(lines, workspace, dryRun);
     formatPreviewFiles(lines, workspace, dryRun);
     formatFormatCommand(lines, result, options);
-    formatWarnings(lines, result);
-    lines.push(`✅ Release preparation complete.`, `   🏷️  ${bold(workspace.tag)}`);
+    formatWarnings(lines, result, style);
+    lines.push(formatStatusLine(style, 'passed', 'Release preparation complete.'), `   ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
     return lines.join('\n');
 }
 function formatMultiWorkspace(result, options) {
     const dryRun = !options.applied;
+    const { style } = options;
     const lines = [];
     for (const workspace of result.workspaces) {
-        formatWorkspaceSection(lines, workspace, dryRun);
+        formatWorkspaceSection(lines, workspace, dryRun, style);
     }
     if (result.project !== undefined) {
-        formatProjectSection(lines, result.project, dryRun);
+        formatProjectSection(lines, result.project, dryRun, style);
     }
     formatFormatCommand(lines, result, options);
-    formatWarnings(lines, result);
+    formatWarnings(lines, result, style);
     if (result.tags.length > 0) {
-        lines.push(`\n✅ Release preparation complete.`);
+        lines.push(`\n${formatStatusLine(style, 'passed', 'Release preparation complete.')}`);
         for (const tag of result.tags) {
-            lines.push(`   🏷️  ${bold(tag)}`);
+            lines.push(`   ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(tag))}`);
         }
     }
     else {
-        lines.push(`\n⏭️  No workspaces had release-worthy changes.`);
+        lines.push(`\n${formatStatusLine(style, 'skipped', 'No workspaces had release-worthy changes.')}`);
     }
     return lines.join('\n');
 }
-function formatProjectSection(lines, project, dryRun) {
+function formatProjectSection(lines, project, dryRun, style) {
     lines.push(`\n${sectionHeader('project')}`);
     const since = project.previousTag === undefined ? '(no previous release found)' : `since ${project.previousTag}`;
     lines.push(dim(`  Found ${project.commitCount} commits ${since}`));
-    formatPolicyViolations(lines, project.policyViolations, '  ');
+    formatPolicyViolations(lines, project.policyViolations, style, '  ');
     if (project.status === 'skipped') {
-        lines.push(`  ⏭️  ${project.skipReason}`);
+        lines.push(`  ${formatStatusLine(style, 'skipped', project.skipReason)}`);
         return;
     }
     const { releaseType, currentVersion, newVersion, tag } = project;
@@ -92,8 +97,8 @@ function formatProjectSection(lines, project, dryRun) {
     if (project.bumpOverride !== undefined) {
         lines.push(`  Using bump override: ${project.bumpOverride}`);
     }
-    formatProjectUnparseable(lines, project);
-    lines.push(dim(`  Bumping versions (${releaseType})...`), `  📦 ${currentVersion} → ${bold(newVersion)} (${releaseType})`);
+    formatProjectUnparseable(lines, project, style);
+    lines.push(dim(`  Bumping versions (${releaseType})...`), `  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${currentVersion} → ${bold(newVersion)} (${releaseType})`)}`);
     for (const file of project.bumpedFiles) {
         if (dryRun) {
             lines.push(dim(`    [dry-run] Would bump ${file}`));
@@ -112,9 +117,9 @@ function formatProjectSection(lines, project, dryRun) {
         }
     }
     formatPreviewFiles(lines, project, dryRun, '  ');
-    lines.push(`  🏷️  ${bold(tag)}`);
+    lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(tag))}`);
 }
-function formatProjectUnparseable(lines, project) {
+function formatProjectUnparseable(lines, project, style) {
     const unparseable = project.unparseableCommits;
     if (unparseable === undefined || unparseable.length === 0) {
         return;
@@ -122,35 +127,35 @@ function formatProjectUnparseable(lines, project) {
     const count = unparseable.length;
     const isPatchFloor = project.parsedCommitCount === 0;
     const suffix = isPatchFloor ? ' (defaulting to patch bump)' : '';
-    lines.push(`    ⚠️  ${count} commit${count === 1 ? '' : 's'} could not be parsed${suffix}`);
+    lines.push(`    ${formatStatusLine(style, 'warning', `${count} commit${count === 1 ? '' : 's'} could not be parsed${suffix}`)}`);
     for (const commit of unparseable) {
         const shortHash = commit.hash.slice(0, 7);
-        const truncatedMessage = commit.message.length > 72 ? `${commit.message.slice(0, 69)}...` : commit.message;
+        const truncatedMessage = truncateSubject(commit.message);
         lines.push(`      · ${shortHash} ${truncatedMessage}`);
     }
 }
-function formatWorkspaceSection(lines, workspace, dryRun) {
+function formatWorkspaceSection(lines, workspace, dryRun, style) {
     if (workspace.name !== undefined) {
         lines.push(`\n${sectionHeader(workspace.name)}`);
     }
     const since = workspace.previousTag === undefined ? '(no previous release found)' : `since ${workspace.previousTag}`;
     lines.push(dim(`  Found ${workspace.commitCount} commits ${since}`));
     if (workspace.status === 'skipped') {
-        lines.push(`  ⏭️  ${workspace.skipReason}`);
+        lines.push(`  ${formatStatusLine(style, 'skipped', workspace.skipReason)}`);
         return;
     }
     const { propagatedFrom } = workspace;
     const isPropagatedOnly = propagatedFrom !== undefined && workspace.commitCount === 0;
     formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly);
-    formatUnparseableWarning(lines, workspace, '  ');
-    formatPolicyViolations(lines, workspace.policyViolations, '  ');
+    formatUnparseableWarning(lines, workspace, style, '  ');
+    formatPolicyViolations(lines, workspace.policyViolations, style, '  ');
     formatBumpLabels(lines, workspace, isPropagatedOnly);
-    formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly);
+    formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style);
     formatBumpFiles(lines, workspace, dryRun, '  ');
     lines.push(dim('  Generating changelogs...'));
     formatChangelogFiles(lines, workspace, dryRun, '  ');
     formatPreviewFiles(lines, workspace, dryRun, '  ');
-    lines.push(`  🏷️  ${bold(workspace.tag)}`);
+    lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'tag', bold(workspace.tag))}`);
 }
 function formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly) {
     if (isPropagatedOnly && propagatedFrom !== undefined) {
@@ -175,13 +180,14 @@ function formatBumpLabels(lines, workspace, isPropagatedOnly) {
         lines.push(dim(`  Bumping versions (version override)...`));
     }
 }
-function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly) {
+function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, style) {
+    const versions = `${workspace.currentVersion} → ${bold(workspace.newVersion)}`;
     if (workspace.setVersion !== undefined) {
-        lines.push(`  📦 ${workspace.currentVersion} → ${bold(workspace.newVersion)} (version override)`);
+        lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (version override)`)}`);
     }
     else if (workspace.releaseType !== undefined) {
         const suffix = isPropagatedOnly ? formatPropagationSuffix(propagatedFrom) : '';
-        lines.push(`  📦 ${workspace.currentVersion} → ${bold(workspace.newVersion)} (${workspace.releaseType}${suffix})`);
+        lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (${workspace.releaseType}${suffix})`)}`);
     }
 }
 function formatBumpFiles(lines, workspace, dryRun, indent = '') {
@@ -215,7 +221,7 @@ function formatPreviewFiles(lines, release, dryRun, indent = '') {
         }
     }
 }
-function formatUnparseableWarning(lines, workspace, indent = '') {
+function formatUnparseableWarning(lines, workspace, style, indent = '') {
     const unparseable = workspace.unparseableCommits;
     if (unparseable === undefined || unparseable.length === 0) {
         return;
@@ -223,23 +229,23 @@ function formatUnparseableWarning(lines, workspace, indent = '') {
     const count = unparseable.length;
     const isPatchFloor = workspace.parsedCommitCount === 0;
     const suffix = isPatchFloor ? ' (defaulting to patch bump)' : '';
-    lines.push(`${indent}  ⚠️  ${count} commit${count === 1 ? '' : 's'} could not be parsed${suffix}`);
+    lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${count} commit${count === 1 ? '' : 's'} could not be parsed${suffix}`)}`);
     for (const commit of unparseable) {
         const shortHash = commit.hash.slice(0, 7);
-        const truncatedMessage = commit.message.length > 72 ? `${commit.message.slice(0, 69)}...` : commit.message;
+        const truncatedMessage = truncateSubject(commit.message);
         lines.push(`${indent}    · ${shortHash} ${truncatedMessage}`);
     }
 }
-function formatPolicyViolations(lines, violations, indent = '') {
+function formatPolicyViolations(lines, violations, style, indent = '') {
     if (violations === undefined || violations.length === 0) {
         return;
     }
     const count = violations.length;
-    lines.push(`${indent}  ⚠️  ${count} policy violation${count === 1 ? '' : 's'}:`);
+    lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${count} policy violation${count === 1 ? '' : 's'}:`)}`);
     for (const violation of violations) {
         const shortHash = violation.commitHash.slice(0, 7);
         const subject = violation.commitSubject;
-        const truncatedSubject = subject.length > 72 ? `${subject.slice(0, 69)}...` : subject;
+        const truncatedSubject = truncateSubject(subject);
         lines.push(`${indent}    · ${shortHash} '${truncatedSubject}' — type '${violation.type}' at ${violation.surface} surface`);
     }
 }
@@ -250,14 +256,14 @@ function formatPropagationSuffix(propagatedFrom) {
     const names = propagatedFrom.map((p) => p.packageName).join(', ');
     return `, dependency: ${names}`;
 }
-function formatWarnings(lines, result) {
+function formatWarnings(lines, result, style) {
     const { warnings } = result;
     if (warnings === undefined || warnings.length === 0) {
         return;
     }
     lines.push('');
     for (const warning of warnings) {
-        lines.push(`⚠️  ${warning}`);
+        lines.push(formatStatusLine(style, 'warning', warning));
     }
 }
 function formatFormatCommand(lines, result, options) {
@@ -272,5 +278,9 @@ function formatFormatCommand(lines, result, options) {
         lines.push(dim(`\n  Running format command: ${result.formatCommand.command}`));
         return;
     }
-    lines.push(`\n  ⚠️  Format command failed: ${result.formatCommand.command}`, `     ${options.formatError}`);
+    const messageIndent = ' '.repeat(2 + measureGlyphColumn(STATUS_GLYPHS[options.style]) + 1);
+    lines.push(`\n  ${formatStatusLine(options.style, 'warning', `Format command failed: ${result.formatCommand.command}`)}`, `${messageIndent}${options.formatError}`);
+}
+function truncateSubject(subject) {
+    return truncateToWidth(subject, { width: SUBJECT_COLUMN_BUDGET });
 }

package/dist/esm/resolveCommandTags.d.ts

@@ -3,7 +3,8 @@ import { type ResolvedTag } from './resolveReleaseTags.js';
  * Discover workspaces, resolve release tags from HEAD, validate `--tags` names against the
  * full resolved tag names (e.g., `nmr-core-v1.3.0`), and return the filtered tag list.
  * Works in both single-package and monorepo modes. Exits with an error message on any validation
- * failure — including `deriveWorkspaceConfig()` throws for workspaces missing a `package.json` `name` field.
+ * failure — including `deriveWorkspaceConfig()` throws for workspaces missing a `package.json` `name` field,
+ * and a workspace declaring patterns that resolve to no package, which is not single-package mode.
  *
  * In both modes `deriveWorkspaceConfig` is called so `WorkspaceConfig.isPublishable` (read
  * from `package.json#private`) propagates onto each `ResolvedTag`. Single-package mode now
@@ -11,4 +12,4 @@ import { type ResolvedTag } from './resolveReleaseTags.js';
  * single-package mode skipping the derive step need a `name` field on `./package.json`,
  * but in practice every npm/pnpm package already has one.
  */
-export declare function resolveCommandTags(tags: string[] | undefined): Promise<ResolvedTag[]>;
+export declare function resolveCommandTags(tags: string[] | undefined): ResolvedTag[];

package/dist/esm/resolveCommandTags.js

@@ -1,25 +1,29 @@
 import { reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
-import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
-export async function resolveCommandTags(tags) {
-    let discoveredPaths;
+export function resolveCommandTags(tags) {
+    let workspace;
     try {
-        discoveredPaths = await discoverWorkspaces();
+        workspace = discoverWorkspaces();
     }
     catch (error) {
         reportError(`Failed to discover workspaces: ${describeError(error)}`);
         process.exit(1);
     }
+    if (workspace.kind === 'empty') {
+        reportError(`No workspace package to tag. ${describeEmptyWorkspace(workspace)}`);
+        process.exit(1);
+    }
     let workspaces;
     let singleWorkspace;
     try {
-        if (discoveredPaths === undefined) {
+        if (workspace.kind === 'single-package') {
             singleWorkspace = deriveWorkspaceConfig('.');
         }
         else {
-            workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+            workspaces = workspace.packageDirs.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
         }
     }
     catch (error) {

package/dist/esm/resolveReleaseNotesConfig.d.ts

@@ -1,3 +1,4 @@
+import type { OutputStyle } from '@williamthorsen/nmr-core';
 import type { ReleaseNotesConfig } from './types.js';
 export interface ResolvedReleaseNotesConfig {
     releaseNotes: ReleaseNotesConfig;
@@ -6,21 +7,19 @@ export interface ResolvedReleaseNotesConfig {
     sectionOrder: string[];
 }
 export interface ResolveReleaseNotesConfigOptions {
-    /**
-     * When `true`, a `loadConfig()` rejection causes `process.exit(1)` rather than a fallback to
-     * defaults. Use from CLI commands whose entire behavior depends on the resolved config (e.g.
-     * `create-github-release`), so a corrupt or unreadable config cannot silently send the command
-     * to the wrong changelog path.
-     */
-    strictLoad?: boolean;
+    /** Config file to read, relative to the working directory. Defaults to `CONFIG_FILE_PATH`. */
+    configPath?: string;
 }
 /**
- * Load and validate the release-kit config.
+ * Loads and validates the release-kit config, resolving the release-notes settings it carries.
  *
- * By default, falls back to defaults when `loadConfig()` rejects (legacy publish behavior).
- * When `strictLoad` is `true`, a load failure prints an error and calls `process.exit(1)`.
+ * An unusable config reports to stderr and calls `process.exit(1)`, whether the file failed to load or failed
+ * validation, and whether it was named by the caller or the default one. Both callers are CLI commands whose
+ * whole behavior depends on the resolved config, so neither could proceed on derived defaults without silently
+ * dropping a configured `releaseNotes.shouldInjectIntoReadme`, `changelogJson.outputPath`, or `workTypes`.
+ * An absent default config is a supported state and resolves to the defaults.
  */
-export declare function resolveReleaseNotesConfig(options?: ResolveReleaseNotesConfigOptions): Promise<ResolvedReleaseNotesConfig>;
+export declare function resolveReleaseNotesConfig(stderrStyle: OutputStyle, options?: ResolveReleaseNotesConfigOptions): Promise<ResolvedReleaseNotesConfig>;
 /** Extract section headers in declaration order from a merged workTypes record. */
 export declare function deriveSectionOrder(workTypes: Record<string, {
     header: string;

package/dist/esm/resolveReleaseNotesConfig.js

@@ -1,40 +1,21 @@
-import { reportError } from '@williamthorsen/nmr-core';
-import { describeError } from '@williamthorsen/toolbelt.errors';
 import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_RELEASE_NOTES_CONFIG } from "./defaults.js";
-import { loadConfig, resolveWorkTypes } from "./loadConfig.js";
-import { validateConfig } from "./validateConfig.js";
-export async function resolveReleaseNotesConfig(options = {}) {
-    const { strictLoad = false } = options;
-    let rawConfig;
-    try {
-        rawConfig = await loadConfig();
-    }
-    catch (error) {
-        const message = describeError(error);
-        if (strictLoad) {
-            reportError(`Failed to load config: ${message}`);
-            process.exit(1);
-        }
-        console.warn(`Warning: failed to load config; using defaults: ${message}`);
+import { resolveWorkTypes } from "./loadConfig.js";
+import { loadValidatedConfig, reportConfigProblem, reportConfigWarnings } from "./loadValidatedConfig.js";
+export async function resolveReleaseNotesConfig(stderrStyle, options = {}) {
+    const result = await loadValidatedConfig(options.configPath);
+    if (result.status === 'invalid') {
+        reportConfigProblem(result.problem, stderrStyle);
+        process.exit(1);
     }
-    if (rawConfig === undefined) {
+    if (result.status === 'missing') {
         return {
             releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG },
             changelogJsonOutputPath: DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
             sectionOrder: deriveSectionOrder(resolveWorkTypes()),
         };
     }
-    const { config, errors, warnings } = validateConfig(rawConfig);
-    if (errors.length > 0) {
-        process.stderr.write('Invalid config:\n');
-        for (const err of errors) {
-            process.stderr.write(`  ❌ ${err}\n`);
-        }
-        process.exit(1);
-    }
-    for (const warning of warnings) {
-        console.warn(`  ⚠️  ${warning}`);
-    }
+    reportConfigWarnings(result.warnings, stderrStyle);
+    const { config } = result;
     return {
         releaseNotes: {
             shouldInjectIntoReadme: config.releaseNotes?.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,

package/dist/esm/resolveStylesOrExit.d.ts

@@ -0,0 +1,10 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
+/** The environment variable holding the caller's standing style preference: `auto`, `plain`, or `rich`. */
+export declare const OUTPUT_STYLE_ENV_VAR = "RELEASE_KIT_OUTPUT_STYLE";
+export interface ResolveStylesOptions {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly stderrIsTty: boolean;
+    readonly stdoutIsTty: boolean;
+}
+/** Resolves the style of each output stream, exiting with a usage error when the variable names no setting. */
+export declare function resolveStylesOrExit(options: ResolveStylesOptions): StreamStyles;

package/dist/esm/resolveStylesOrExit.js

@@ -0,0 +1,10 @@
+import { describeInvalidOutputStyle, reportError, resolveStreamStyles, } from '@williamthorsen/nmr-core';
+export const OUTPUT_STYLE_ENV_VAR = 'RELEASE_KIT_OUTPUT_STYLE';
+export function resolveStylesOrExit(options) {
+    const { invalid, styles } = resolveStreamStyles({ ...options, envVar: OUTPUT_STYLE_ENV_VAR });
+    if (invalid !== undefined) {
+        reportError(describeInvalidOutputStyle(invalid));
+        process.exit(1);
+    }
+    return styles;
+}

package/dist/esm/showTagPrefixesCommand.d.ts

@@ -1,3 +1,4 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
 /**
  * Orchestrate the CLI `show-tag-prefixes` command.
  *
@@ -5,8 +6,10 @@
  * entries, followed by an "Undeclared tag prefixes" section when candidate-shaped tags
  * exist outside the known set. Exits `0` on full derivation success and no collisions;
  * `1` on any derivation failure or collision. Undeclared candidates do not affect the
- * exit code.
+ * exit code. A config that exists and either fails to load or fails validation reports to stderr and
+ * exits `1` in both repo modes, rather than falling back to a default-config preview that would
+ * understate the declared legacy prefixes. An absent default config previews against derived defaults.
  *
  * @returns The exit code the caller should use.
  */
-export declare function showTagPrefixesCommand(): Promise<number>;
+export declare function showTagPrefixesCommand(styles: StreamStyles, configPath?: string): Promise<number>;

package/dist/esm/showTagPrefixesCommand.js

@@ -1,12 +1,27 @@
+import { formatStatusLine, reportError } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
 import { detectRepoType } from "./init/detectRepoType.js";
+import { loadValidatedConfig, reportConfigProblem } from "./loadValidatedConfig.js";
 import { previewTagPrefixes } from "./previewTagPrefixes.js";
-export async function showTagPrefixesCommand() {
+export async function showTagPrefixesCommand(styles, configPath) {
+    const result = await loadValidatedConfig(configPath);
+    if (result.status === 'invalid') {
+        reportConfigProblem(result.problem, styles.stderr);
+        return 1;
+    }
     if (detectRepoType() === 'single-package') {
         process.stdout.write(renderSinglePackage());
         return 0;
     }
-    const preview = await previewTagPrefixes();
-    process.stdout.write(renderMonorepo(preview));
+    let preview;
+    try {
+        preview = previewTagPrefixes(result.status === 'ok' ? result.config : undefined);
+    }
+    catch (error) {
+        reportError(describeError(error));
+        return 1;
+    }
+    process.stdout.write(renderMonorepo(preview, styles.stdout));
     return computeExitCode(preview);
 }
 function renderSinglePackage() {
@@ -17,13 +32,13 @@ function renderSinglePackage() {
     ];
     return lines.join('\n');
 }
-function renderMonorepo(preview) {
+function renderMonorepo(preview, style) {
     const lines = ['Workspace tag prefixes:', ''];
     for (const row of preview.workspaces) {
-        lines.push(...renderWorkspaceRow(row));
+        lines.push(...renderWorkspaceRow(row, style));
     }
     if (preview.collisions.length > 0) {
-        lines.push('', ...preview.collisions.map((collision) => `⛔ tag prefix collision: '${collision.tagPrefix}' used by ${collision.workspacePaths.join(', ')}`));
+        lines.push('', ...preview.collisions.map((collision) => formatStatusLine(style, 'failed', `tag prefix collision: '${collision.tagPrefix}' used by ${collision.workspacePaths.join(', ')}`)));
     }
     if (preview.undeclaredCandidates.length > 0) {
         lines.push('', 'Undeclared tag prefixes:', '', ...preview.undeclaredCandidates.map((candidate) => `  '${candidate.prefix}' — ${candidate.tagCount} tags (e.g., ${candidate.exampleTags.join(', ')})`), '', 'Suggested config snippet (adjust `dir` to match your workspace if the guess is wrong, and replace the `name` placeholder with the legacy npm name):', '', renderSuggestedSnippet(preview.undeclaredCandidates), '', "If the suggested `dir` does not match your workspace, adjust before pasting. Each legacy identity requires a `name` — replace the `TODO-fill-in-legacy-npm-name` placeholder with the package's prior npm name.");
@@ -31,20 +46,25 @@ function renderMonorepo(preview) {
     lines.push('');
     return lines.join('\n');
 }
-function renderWorkspaceRow(row) {
+function renderWorkspaceRow(row, style) {
     const lines = [];
     if (row.derivedPrefix === null) {
-        lines.push(`  ${row.workspacePath} — ⛔ derivation failed: ${row.derivationError ?? 'unknown error'}`);
+        const failure = formatStatusLine(style, 'failed', `derivation failed: ${row.derivationError ?? 'unknown error'}`);
+        lines.push(`  ${row.workspacePath} — ${failure}`);
         return lines;
     }
-    const statusMarker = row.derivedTagCount > 0 ? `✅ ${row.derivedTagCount} tags` : '⚠️ no existing tags';
+    const statusMarker = row.derivedTagCount > 0
+        ? formatStatusLine(style, 'passed', `${row.derivedTagCount} tags`)
+        : formatStatusLine(style, 'warning', 'no existing tags');
     lines.push(`  ${row.workspacePath} — derived prefix '${row.derivedPrefix}', ${statusMarker}`);
     for (const entry of row.legacyEntries) {
         if (entry.tagCount > 0) {
-            lines.push(`      ✅ ${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`);
+            const recognized = `${entry.tagCount} legacy tags with '${entry.prefix}' prefix (recognized)`;
+            lines.push(`      ${formatStatusLine(style, 'passed', recognized)}`);
         }
         else {
-            lines.push(`      ⚠️ recorded legacy prefix '${entry.prefix}' has no tags`);
+            const tagless = `recorded legacy prefix '${entry.prefix}' has no tags`;
+            lines.push(`      ${formatStatusLine(style, 'warning', tagless)}`);
         }
     }
     return lines;

package/dist/esm/sync-labels/generateCommand.d.ts

@@ -1,27 +1,37 @@
+import { type OutputStyle, type StreamStyles } from '@williamthorsen/nmr-core';
 import type { RepoLabelsConfig } from '../types.js';
 import type { LabelDefinition } from './types.js';
 /** Output path for the generated labels file. */
 export declare const LABELS_OUTPUT_PATH = ".github/labels.yaml";
-/** Formats resolved labels as YAML with generated header including preset hashes. */
-export declare function formatLabelsYaml(labels: LabelDefinition[], presetHashes: Map<string, string>): string;
 /**
- * Loads `.config/release-kit.config.ts` and returns its `repoLabels` block.
+ * Formats resolved labels as YAML with generated header including preset hashes.
+ *
+ * `configFilePath` is recorded in the header so that a reader of the generated file can find the config it came
+ * from; it defaults to `CONFIG_FILE_PATH`.
+ */
+export declare function formatLabelsYaml(labels: LabelDefinition[], presetHashes: Map<string, string>, configFilePath?: string): string;
+/**
+ * Loads the config file and returns its `repoLabels` block.
  *
  * Reports an actionable error and returns `undefined` when the config file is missing,
- * fails to load or validate, or carries no `repoLabels` block.
+ * fails to load or validate, or carries no `repoLabels` block. Every message names the file
+ * this run read, so that `--config` never points the reader at the default path.
  */
-export declare function loadRepoLabelsConfig(): Promise<RepoLabelsConfig | undefined>;
+export declare function loadRepoLabelsConfig(stderrStyle: OutputStyle, configPath?: string): Promise<RepoLabelsConfig | undefined>;
 /** Options for the `sync-labels generate` subcommand. */
 interface GenerateOptions {
     /** Compare the regenerated content against the committed file instead of writing. */
     check?: boolean;
+    /** Config file to read, relative to the working directory. Defaults to `CONFIG_FILE_PATH`. */
+    configPath?: string;
+    styles: StreamStyles;
 }
 /**
  * Runs the `sync-labels generate` command.
  *
- * Loads the `repoLabels` block from `.config/release-kit.config.ts`, resolves presets and label adjustments,
- * and writes `.github/labels.yaml` -- or, with `check`, regenerates in memory and reports whether the committed file
+ * Loads the `repoLabels` block from the config file, resolves presets and label adjustments, and writes
+ * `.github/labels.yaml` -- or, with `check`, regenerates in memory and reports whether the committed file
  * is stale, writing nothing. Returns 0 on success, 1 on failure.
  */
-export declare function generateCommand({ check }?: GenerateOptions): Promise<number>;
+export declare function generateCommand({ check, configPath, styles }: GenerateOptions): Promise<number>;
 export {};

package/dist/esm/sync-labels/generateCommand.js

@@ -4,13 +4,13 @@ import { reportError } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { stringify } from 'yaml';
 import { CONFIG_FILE_PATH } from "../loadConfig.js";
-import { loadValidatedConfig } from "../loadValidatedConfig.js";
+import { loadValidatedConfig, reportConfigProblem } from "../loadValidatedConfig.js";
 import { hashPresetFile } from "./presets.js";
 import { resolveLabels } from "./resolveLabels.js";
 import { checkRetiredSyncLabelsConfig } from "./retiredConfig.js";
 export const LABELS_OUTPUT_PATH = '.github/labels.yaml';
-export function formatLabelsYaml(labels, presetHashes) {
-    const headerLines = ['# Generated by release-kit sync-labels — do not edit.', `# Source: ${CONFIG_FILE_PATH}`];
+export function formatLabelsYaml(labels, presetHashes, configFilePath = CONFIG_FILE_PATH) {
+    const headerLines = ['# Generated by release-kit sync-labels — do not edit.', `# Source: ${configFilePath}`];
     const sortedPresetHashes = [...presetHashes].sort(([a], [b]) => a.localeCompare(b));
     for (const [name, hash] of sortedPresetHashes) {
         headerLines.push(`# ${name} preset hash: ${hash}`);
@@ -19,26 +19,27 @@ export function formatLabelsYaml(labels, presetHashes) {
     const yamlBody = stringify(declared, { singleQuote: true, lineWidth: 0 });
     return headerLines.join('\n') + '\n' + yamlBody;
 }
-export async function loadRepoLabelsConfig() {
-    const result = await loadValidatedConfig();
+export async function loadRepoLabelsConfig(stderrStyle, configPath) {
+    const result = await loadValidatedConfig(configPath);
     if (result.status === 'missing') {
-        reportError(`No config file found at ${CONFIG_FILE_PATH}. Run \`release-kit sync-labels init\` first.`);
+        reportError(`No config file found at ${result.configFilePath}. Run \`release-kit sync-labels init\` first.`);
         return undefined;
     }
     if (result.status === 'invalid') {
+        reportConfigProblem(result.problem, stderrStyle);
         return undefined;
     }
     if (result.config.repoLabels === undefined) {
-        reportError(`No \`repoLabels\` block found in ${CONFIG_FILE_PATH}. Run \`release-kit sync-labels init\` to seed one.`);
+        reportError(`No \`repoLabels\` block found in ${result.configFilePath}. Run \`release-kit sync-labels init\` to seed one.`);
         return undefined;
     }
     return result.config.repoLabels;
 }
-export async function generateCommand({ check = false } = {}) {
-    if (checkRetiredSyncLabelsConfig()) {
+export async function generateCommand({ check = false, configPath, styles }) {
+    if (checkRetiredSyncLabelsConfig(configPath)) {
         return 1;
     }
-    const repoLabels = await loadRepoLabelsConfig();
+    const repoLabels = await loadRepoLabelsConfig(styles.stderr, configPath);
     if (repoLabels === undefined) {
         return 1;
     }
@@ -56,7 +57,7 @@ export async function generateCommand({ check = false } = {}) {
     for (const presetName of presetNames) {
         presetHashes.set(presetName, hashPresetFile(presetName));
     }
-    const content = formatLabelsYaml(labels, presetHashes);
+    const content = formatLabelsYaml(labels, presetHashes, configPath);
     if (check) {
         return compareAgainstCommittedFile(content);
     }