@williamthorsen/release-kit 18.1.1 → 18.3.0

package/dist/esm/enumerateReleaseWindows.js

@@ -1,11 +1,7 @@
-import { execFileSync } from 'node:child_process';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
 import { matchesTagPrefix } from "./matchesTagPrefix.js";
 import { chainUserError } from "./user-error-chaining.js";
-const FIELD_SEPARATOR = '\u{1F}';
-const RECORD_SEPARATOR = '\u{1E}';
 export function enumerateReleaseWindows(options) {
-    const { now = Date.now, paths, tagPrefixes, unreleasedTag } = options;
+    const { git, now = Date.now, paths, tagPrefixes, unreleasedTag } = options;
     if (tagPrefixes.length === 0) {
         throw new Error('enumerateReleaseWindows: tagPrefixes must contain at least one entry');
     }
@@ -14,18 +10,18 @@ export function enumerateReleaseWindows(options) {
         timestampSec: Math.floor(now() / 1000),
         commits: [],
     };
-    const ancestry = readAncestry();
+    const ancestry = readAncestry(git);
     if (ancestry.parentsByHash.size === 0) {
         return [unreleasedWindow];
     }
-    const boundaries = readTagBoundaries(tagPrefixes, ancestry.positionByHash);
+    const boundaries = readTagBoundaries(git, tagPrefixes, ancestry.positionByHash);
     const releasedWindows = boundaries.map((boundary) => ({
         version: boundary.tag,
         timestampSec: boundary.timestampSec,
         commits: [],
     }));
     const windowIndexByHash = claimAncestors(boundaries, ancestry.parentsByHash);
-    for (const commit of readCommits(paths).toReversed()) {
+    for (const commit of readCommits(git, paths).toReversed()) {
         const windowIndex = windowIndexByHash.get(commit.hash);
         const window = windowIndex === undefined ? unreleasedWindow : (releasedWindows[windowIndex] ?? unreleasedWindow);
         window.commits.push(commit);
@@ -47,74 +43,35 @@ function claimAncestors(boundaries, parentsByHash) {
     }
     return windowIndexByHash;
 }
-function parseCommitRecord(record) {
-    const [hash, subject, message] = record.replace(/^\n+/, '').split(FIELD_SEPARATOR);
-    if (hash === undefined || subject === undefined || message === undefined || hash === '') {
-        return undefined;
-    }
-    const trimmedMessage = message.replace(/\s+$/, '');
-    const bodyStart = trimmedMessage.indexOf('\n\n');
-    const body = bodyStart === -1 ? '' : trimmedMessage.slice(bodyStart + 2);
-    return { hash, subject, body, message: trimmedMessage };
-}
-function readAncestry() {
-    const args = ['rev-list', '--topo-order', '--parents', '--ignore-missing', 'HEAD'];
-    const output = runGit(args, `'git rev-list' for HEAD`);
+function readAncestry(git) {
+    const entries = runGitRead(() => git.readAncestry(), `'git rev-list' for HEAD`);
     const ancestry = { parentsByHash: new Map(), positionByHash: new Map() };
-    for (const [position, line] of output.split('\n').entries()) {
-        const [hash, ...parents] = line.split(' ');
-        if (hash === undefined || hash === '') {
-            continue;
-        }
+    for (const [position, { hash, parents }] of entries.entries()) {
         ancestry.parentsByHash.set(hash, parents);
         ancestry.positionByHash.set(hash, position);
     }
     return ancestry;
 }
-function readCommits(paths) {
-    const format = `%H${FIELD_SEPARATOR}%s${FIELD_SEPARATOR}%B${RECORD_SEPARATOR}`;
-    const args = ['log', 'HEAD', `--pretty=format:${format}`];
-    if (paths !== undefined && paths.length > 0) {
-        args.push('--', ...paths);
-    }
-    const output = runGit(args, `'git log' for HEAD`);
-    const commits = [];
-    for (const record of output.split(RECORD_SEPARATOR)) {
-        const commit = parseCommitRecord(record);
-        if (commit !== undefined) {
-            commits.push(commit);
-        }
-    }
-    return commits;
+function readCommits(git, paths) {
+    return runGitRead(() => git.readCommits(paths), `'git log' for HEAD`);
 }
-function readTagBoundaries(tagPrefixes, positionByHash) {
-    const fields = ['%(refname:strip=2)', '%(creatordate:unix)', '%(objectname)', '%(*objectname)'];
-    const args = ['for-each-ref', `--format=${fields.join('%1f')}`, 'refs/tags'];
-    const output = runGit(args, `'git for-each-ref' for refs/tags`);
+function readTagBoundaries(git, tagPrefixes, positionByHash) {
+    const refs = runGitRead(() => git.listTagRefs(), `'git for-each-ref' for refs/tags`);
     const boundaries = [];
-    for (const line of output.split('\n')) {
-        const [tag, creatorDate, objectName, dereferencedName] = line.split(FIELD_SEPARATOR);
-        if (tag === undefined ||
-            creatorDate === undefined ||
-            objectName === undefined ||
-            !matchesTagPrefix(tag, tagPrefixes)) {
+    for (const { tag, timestampSec, commitHash } of refs) {
+        if (!matchesTagPrefix(tag, tagPrefixes)) {
             continue;
         }
-        const hash = dereferencedName || objectName;
-        const position = positionByHash.get(hash);
+        const position = positionByHash.get(commitHash);
         if (position !== undefined) {
-            boundaries.push({ hash, position, tag, timestampSec: Number(creatorDate) });
+            boundaries.push({ hash: commitHash, position, tag, timestampSec });
         }
     }
     return boundaries.toSorted((left, right) => right.position - left.position);
 }
-function runGit(args, description) {
+function runGitRead(read, description) {
     try {
-        return execFileSync('git', args, {
-            encoding: 'utf8',
-            maxBuffer: GIT_OUTPUT_LIMIT_BYTES,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
+        return read();
     }
     catch (error) {
         throw chainUserError(`Failed to run ${description}`, error);

package/dist/esm/findUnroutedEntryScopes.d.ts

@@ -1,4 +1,4 @@
-import type { RawCommit } from './enumerateReleaseWindows.js';
+import type { RawCommit } from './git.js';
 import type { UnroutedEntryScope } from './types.js';
 /** A workspace target's name, the scope that routes to it, with the commits of its unreleased window. */
 export interface WorkspaceWindow {

package/dist/esm/git.d.ts

@@ -0,0 +1,61 @@
+/** A commit reachable from HEAD and the hashes of its parents. */
+export interface AncestryEntry {
+    hash: string;
+    parents: string[];
+}
+/** Returns the arguments of the `git push` that publishes `branch` to `origin`. */
+export declare function buildBranchPushArgs(branch: string): string[];
+/** Returns the arguments of the `git push` that publishes `tag` alone to `origin`. */
+export declare function buildTagPushArgs(tag: string): string[];
+/** The git operations that release-kit runs, each returning parsed output and throwing when git fails. */
+export interface Git {
+    /** Stages every change in the working tree. */
+    addAll(): void;
+    /** Creates a commit with `message`. */
+    commit(message: string): void;
+    /** Creates an annotated tag at HEAD whose message is its name. */
+    createAnnotatedTag(tag: string): void;
+    /** Reports whether a tracked file has staged or unstaged changes; untracked files do not count. */
+    hasTrackedChanges(): boolean;
+    /** Reports whether the working directory is inside a git work tree; never throws. */
+    isInsideWorkTree(): boolean;
+    /** Lists the tags whose names match `pattern`, every tag when it is absent. */
+    listTags(pattern?: string): string[];
+    /** Lists the tags that point at HEAD. */
+    listTagsAtHead(): string[];
+    /** Lists every tag with its creation date and the commit at which it points. */
+    listTagRefs(): TagRef[];
+    /** Pushes `branch` to `origin`, with git's output on the terminal. */
+    pushBranch(branch: string): void;
+    /** Pushes `tag` alone to `origin`, with git's output on the terminal. */
+    pushTag(tag: string): void;
+    /** Reads every commit reachable from HEAD in topological order, newest first; empty for an unborn HEAD. */
+    readAncestry(): AncestryEntry[];
+    /** Reads every commit reachable from HEAD that touches one of `paths`, or any path when it is absent, newest first. */
+    readCommits(paths?: readonly string[]): RawCommit[];
+    /** Returns the name of the checked-out branch. */
+    readCurrentBranch(): string;
+    /** Returns the `git status --porcelain` output without its trailing newline, empty when the tree is clean. */
+    readStatus(): string;
+}
+/** A commit as git records it, before any parsing or filtering. */
+export interface RawCommit {
+    /** The full 40-character hash. */
+    hash: string;
+    /** The first line, with a wrapped subject folded onto one line by git. */
+    subject: string;
+    /** The message after its first blank line, empty when the commit does not have a body. */
+    body: string;
+    /** The raw commit message, subject and body together. */
+    message: string;
+}
+/** The `Git` that runs git in the process's working directory. */
+export declare const realGit: Git;
+/** A tag, the date on which it was created, and the commit at which it points. */
+export interface TagRef {
+    tag: string;
+    /** Unix seconds: the tagger date for an annotated tag, the commit date for a lightweight one. */
+    timestampSec: number;
+    /** The commit at which the tag points, dereferenced for an annotated tag. */
+    commitHash: string;
+}

package/dist/esm/git.js

@@ -0,0 +1,101 @@
+import { execFileSync } from 'node:child_process';
+import { runGit } from '@williamthorsen/nmr-core';
+export function buildBranchPushArgs(branch) {
+    return ['push', 'origin', branch];
+}
+export function buildTagPushArgs(tag) {
+    return ['push', '--no-follow-tags', 'origin', tag];
+}
+export const realGit = {
+    addAll: () => {
+        readGitOutput(['add', '-A']);
+    },
+    commit: (message) => {
+        readGitOutput(['commit', '-m', message]);
+    },
+    createAnnotatedTag: (tag) => {
+        readGitOutput(['tag', '-a', tag, '-m', tag]);
+    },
+    hasTrackedChanges: () => readGitOutput(['status', '--porcelain', '--untracked-files=no']).trim().length > 0,
+    isInsideWorkTree: () => runGit(['rev-parse', '--is-inside-work-tree'], process.cwd()).ok,
+    listTags: (pattern) => splitLines(readGitOutput(pattern === undefined ? ['tag', '--list'] : ['tag', '--list', pattern])),
+    listTagsAtHead: () => splitLines(readGitOutput(['tag', '--points-at', 'HEAD'])),
+    listTagRefs,
+    pushBranch: (branch) => {
+        pushWithTerminalOutput(buildBranchPushArgs(branch));
+    },
+    pushTag: (tag) => {
+        pushWithTerminalOutput(buildTagPushArgs(tag));
+    },
+    readAncestry,
+    readCommits,
+    readCurrentBranch: () => readGitOutput(['rev-parse', '--abbrev-ref', 'HEAD']).trim(),
+    readStatus: () => readGitOutput(['status', '--porcelain']).trimEnd(),
+};
+const FIELD_SEPARATOR = '\u{1F}';
+const RECORD_SEPARATOR = '\u{1E}';
+function listTagRefs() {
+    const fields = ['%(refname:strip=2)', '%(creatordate:unix)', '%(objectname)', '%(*objectname)'];
+    const output = readGitOutput(['for-each-ref', `--format=${fields.join('%1f')}`, 'refs/tags']).trim();
+    const refs = [];
+    for (const line of output.split('\n')) {
+        const [tag, creatorDate, objectName, dereferencedName] = line.split(FIELD_SEPARATOR);
+        if (tag === undefined || tag === '' || creatorDate === undefined || objectName === undefined) {
+            continue;
+        }
+        refs.push({ tag, timestampSec: Number(creatorDate), commitHash: dereferencedName || objectName });
+    }
+    return refs;
+}
+function parseCommitRecord(record) {
+    const [hash, subject, message] = record.replace(/^\n+/, '').split(FIELD_SEPARATOR);
+    if (hash === undefined || subject === undefined || message === undefined || hash === '') {
+        return undefined;
+    }
+    const trimmedMessage = message.replace(/\s+$/, '');
+    const bodyStart = trimmedMessage.indexOf('\n\n');
+    const body = bodyStart === -1 ? '' : trimmedMessage.slice(bodyStart + 2);
+    return { hash, subject, body, message: trimmedMessage };
+}
+function pushWithTerminalOutput(args) {
+    execFileSync('git', args, { stdio: 'inherit' });
+}
+function readAncestry() {
+    const output = readGitOutput(['rev-list', '--topo-order', '--parents', '--ignore-missing', 'HEAD']).trim();
+    const entries = [];
+    for (const line of output.split('\n')) {
+        const [hash, ...parents] = line.split(' ');
+        if (hash !== undefined && hash !== '') {
+            entries.push({ hash, parents });
+        }
+    }
+    return entries;
+}
+function readCommits(paths) {
+    const format = `%H${FIELD_SEPARATOR}%s${FIELD_SEPARATOR}%B${RECORD_SEPARATOR}`;
+    const args = ['log', 'HEAD', `--pretty=format:${format}`];
+    if (paths !== undefined && paths.length > 0) {
+        args.push('--', ...paths);
+    }
+    const commits = [];
+    for (const record of readGitOutput(args).trim().split(RECORD_SEPARATOR)) {
+        const commit = parseCommitRecord(record);
+        if (commit !== undefined) {
+            commits.push(commit);
+        }
+    }
+    return commits;
+}
+function readGitOutput(args) {
+    const result = runGit(args, process.cwd());
+    if (!result.ok) {
+        throw new Error(result.error);
+    }
+    return result.stdout;
+}
+function splitLines(output) {
+    return output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}

package/dist/esm/init/checks.d.ts

@@ -1,10 +1,11 @@
+import { type Git } from '../git.js';
 /** Result of an eligibility check. */
 export interface CheckResult {
     ok: boolean;
     message?: string;
 }
 /** Verifies that the current directory is inside a git repository. */
-export declare function isGitRepo(): CheckResult;
+export declare function isGitRepo(git?: Git): CheckResult;
 /** Verifies that package.json exists in the current directory. */
 export declare function hasPackageJson(): CheckResult;
 /** Verifies that the project uses pnpm, signaled by pnpm-lock.yaml or a pnpm `packageManager` field. */

package/dist/esm/init/checks.js

@@ -1,15 +1,10 @@
-import { execSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
-import { GIT_OUTPUT_LIMIT_BYTES } from '@williamthorsen/nmr-core';
+import { realGit } from "../git.js";
 import { parseJsonRecord } from "./parseJsonRecord.js";
-export function isGitRepo() {
-    try {
-        execSync('git rev-parse --is-inside-work-tree', { maxBuffer: GIT_OUTPUT_LIMIT_BYTES, stdio: 'pipe' });
-        return { ok: true };
-    }
-    catch {
-        return { ok: false, message: 'Not inside a git repository. Run `git init` first.' };
-    }
+export function isGitRepo(git = realGit) {
+    return git.isInsideWorkTree()
+        ? { ok: true }
+        : { ok: false, message: 'Not inside a git repository. Run `git init` first.' };
 }
 export function hasPackageJson() {
     if (existsSync('package.json')) {

package/dist/esm/init/eligibility.d.ts

@@ -0,0 +1,12 @@
+import { type StreamStyles } from '@williamthorsen/nmr-core';
+import { type RepoType } from './detectRepoType.js';
+/** Runs the eligibility checks, stopping at the first failure, and reports whether all passed. */
+export declare function checkEligibility(styles: StreamStyles): boolean;
+/**
+ * Runs the preamble shared by the scaffolding commands and returns the detected repo type, or `undefined` once it has
+ * reported a failed check or an anticipated error.
+ */
+export declare function resolveEligibleRepoType({ isDryRun, styles, }: {
+    isDryRun: boolean;
+    styles: StreamStyles;
+}): RepoType | undefined;

package/dist/esm/init/eligibility.js

@@ -0,0 +1,50 @@
+import { isAnticipatedFailure, printError, printStep, printSuccess } from '@williamthorsen/nmr-core';
+import { describeError } from '@williamthorsen/toolbelt.errors';
+import { hasPackageJson, isGitRepo, usesPnpm } from "./checks.js";
+import { detectRepoType } from "./detectRepoType.js";
+export function checkEligibility(styles) {
+    printStep('Checking eligibility');
+    return (runRequiredCheck('Git repository detected', isGitRepo(), styles) &&
+        runRequiredCheck('package.json found', hasPackageJson(), styles) &&
+        runRequiredCheck('pnpm detected', usesPnpm(), styles));
+}
+export function resolveEligibleRepoType({ isDryRun, styles, }) {
+    if (isDryRun) {
+        console.info('[dry-run mode]');
+    }
+    let eligible;
+    try {
+        eligible = checkEligibility(styles);
+    }
+    catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
+        printError(`Eligibility check failed: ${describeError(error)}`, styles.stderr);
+        return undefined;
+    }
+    if (!eligible)
+        return undefined;
+    printStep('Detecting repo type');
+    let repoType;
+    try {
+        repoType = detectRepoType();
+    }
+    catch (error) {
+        if (!isAnticipatedFailure(error)) {
+            throw error;
+        }
+        printError(`Failed to detect repo type: ${describeError(error)}`, styles.stderr);
+        return undefined;
+    }
+    printSuccess(`Detected: ${repoType}`, styles.stdout);
+    return repoType;
+}
+function runRequiredCheck(label, result, styles) {
+    if (result.ok) {
+        printSuccess(label, styles.stdout);
+        return true;
+    }
+    printError(result.message ?? `${label} failed`, styles.stderr);
+    return false;
+}

package/dist/esm/init/initCommand.d.ts

@@ -5,8 +5,6 @@ interface InitOptions {
     styles: StreamStyles;
     shouldScaffoldConfig: boolean;
 }
-/** Runs the eligibility checks, stopping at the first failure, and reports whether all passed. */
-export declare function checkEligibility(styles: StreamStyles): boolean;
 /** Runs the `release-kit init` command and returns the process exit code. */
 export declare function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfig }: InitOptions): number;
 export {};

package/dist/esm/init/initCommand.js

@@ -1,45 +1,12 @@
-import { isAnticipatedFailure, printError, printSkip, printStep, printSuccess, reportWriteResult, } from '@williamthorsen/nmr-core';
+import { isAnticipatedFailure, printError, printSkip, printStep, reportWriteResult, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
-import { hasPackageJson, isGitRepo, usesPnpm } from "./checks.js";
-import { detectRepoType } from "./detectRepoType.js";
+import { resolveEligibleRepoType } from "./eligibility.js";
 import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
 import { PUBLISHING_WORKFLOW_PATHS, scaffoldFiles } from "./scaffold.js";
-export function checkEligibility(styles) {
-    printStep('Checking eligibility');
-    return (runRequiredCheck('Git repository detected', isGitRepo(), styles) &&
-        runRequiredCheck('package.json found', hasPackageJson(), styles) &&
-        runRequiredCheck('pnpm detected', usesPnpm(), styles));
-}
 export function initCommand({ isDryRun, shouldForce, styles, shouldScaffoldConfig }) {
-    if (isDryRun) {
-        console.info('[dry-run mode]');
-    }
-    let eligible;
-    try {
-        eligible = checkEligibility(styles);
-    }
-    catch (error) {
-        if (!isAnticipatedFailure(error)) {
-            throw error;
-        }
-        printError(`Eligibility check failed: ${describeError(error)}`, styles.stderr);
-        return 1;
-    }
-    if (!eligible)
+    const repoType = resolveEligibleRepoType({ isDryRun, styles });
+    if (repoType === undefined)
         return 1;
-    printStep('Detecting repo type');
-    let repoType;
-    try {
-        repoType = detectRepoType();
-    }
-    catch (error) {
-        if (!isAnticipatedFailure(error)) {
-            throw error;
-        }
-        printError(`Failed to detect repo type: ${describeError(error)}`, styles.stderr);
-        return 1;
-    }
-    printSuccess(`Detected: ${repoType}`, styles.stdout);
     const publishable = hasPublishablePackage();
     printStep('Scaffolding files');
     if (!publishable) {
@@ -80,11 +47,3 @@ function formatNextSteps({ publishable, shouldScaffoldConfig, }) {
     ];
     return steps.map((step, index) => `  ${String(index + 1)}. ${step}`).join('\n');
 }
-function runRequiredCheck(label, result, styles) {
-    if (result.ok) {
-        printSuccess(label, styles.stdout);
-        return true;
-    }
-    printError(result.message ?? `${label} failed`, styles.stderr);
-    return false;
-}

package/dist/esm/init/managed-workflows.d.ts

@@ -0,0 +1,10 @@
+import type { RepoType } from './detectRepoType.js';
+/** Renders the create-github-release workflow that the repo should contain. */
+export declare function renderExpectedCreateGithubReleaseWorkflow(repoType: RepoType): string;
+/**
+ * Renders the publish workflow that the repo should contain, keeping the provenance setting of the existing
+ * `publish.yaml` and enabling provenance when the file is missing.
+ */
+export declare function renderExpectedPublishWorkflow(repoType: RepoType): string;
+/** Renders the release workflow that the repo should contain. */
+export declare function renderExpectedReleaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/managed-workflows.js

@@ -0,0 +1,18 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { hasProvenance } from "./hasProvenance.js";
+import { PUBLISH_WORKFLOW_PATH } from "./scaffold.js";
+import { renderCreateGithubReleaseWorkflow, renderPublishWorkflow, renderReleaseWorkflow } from "./templates.js";
+export function renderExpectedCreateGithubReleaseWorkflow(repoType) {
+    return renderCreateGithubReleaseWorkflow(repoType);
+}
+export function renderExpectedPublishWorkflow(repoType) {
+    return renderPublishWorkflow(repoType, { shouldGenerateProvenance: readProvenanceSetting() });
+}
+export function renderExpectedReleaseWorkflow(repoType) {
+    return renderReleaseWorkflow(repoType);
+}
+function readProvenanceSetting() {
+    if (!existsSync(PUBLISH_WORKFLOW_PATH))
+        return true;
+    return hasProvenance(readFileSync(PUBLISH_WORKFLOW_PATH, 'utf8'));
+}

package/dist/esm/init/templates.js

@@ -15,7 +15,7 @@ export default defineConfig({
   // Formatting: prettier is auto-detected. Set formatCommand to override.
 
   // Uncomment to override the default version patterns:
-  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'], none: ['ai', 'ci', 'docs', 'tests', 'tooling'] },
 
   // Uncomment to add custom work types (merged with defaults):
   // workTypes: { perf: { header: 'Performance' } },
@@ -32,7 +32,7 @@ export default defineConfig({
   // Formatting: prettier is auto-detected. Set formatCommand to override.
 
   // Uncomment to override the default version patterns:
-  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'] },
+  // versionPatterns: { major: ['!'], minor: ['feat', 'feature'], none: ['ai', 'ci', 'docs', 'tests', 'tooling'] },
 
   // Uncomment to add custom work types (merged with defaults):
   // workTypes: { perf: { header: 'Performance' } },

package/dist/esm/init/updateTemplatesCommand.js

@@ -1,44 +1,16 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { isAnticipatedFailure, printError, printSkip, printStep, printSuccess, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
+import { existsSync } from 'node:fs';
+import { isAnticipatedFailure, printError, printSkip, printStep, reportTemplateUpdate, updateManagedFile, } from '@williamthorsen/nmr-core';
 import { describeError } from '@williamthorsen/toolbelt.errors';
 import { readSyncLabelsWorkflowTemplate } from "../sync-labels/templates.js";
-import { detectRepoType } from "./detectRepoType.js";
-import { hasProvenance } from "./hasProvenance.js";
+import { resolveEligibleRepoType } from "./eligibility.js";
 import { formatPrivateWorkflowSkip, hasPublishablePackage } from "./hasPublishablePackage.js";
-import { checkEligibility } from "./initCommand.js";
+import { renderExpectedCreateGithubReleaseWorkflow, renderExpectedPublishWorkflow, renderExpectedReleaseWorkflow, } from "./managed-workflows.js";
 import { CREATE_GITHUB_RELEASE_WORKFLOW_PATH, PUBLISH_WORKFLOW_PATH, PUBLISHING_WORKFLOW_PATHS } from "./scaffold.js";
-import { renderCreateGithubReleaseWorkflow, renderPublishWorkflow, renderReleaseWorkflow } from "./templates.js";
 const SYNC_LABELS_WORKFLOW_PATH = '.github/workflows/sync-labels.yaml';
 export function updateTemplatesCommand({ isDryRun, styles }) {
-    if (isDryRun) {
-        console.info('[dry-run mode]');
-    }
-    let eligible;
-    try {
-        eligible = checkEligibility(styles);
-    }
-    catch (error) {
-        if (!isAnticipatedFailure(error)) {
-            throw error;
-        }
-        printError(`Eligibility check failed: ${describeError(error)}`, styles.stderr);
-        return 1;
-    }
-    if (!eligible)
+    const repoType = resolveEligibleRepoType({ isDryRun, styles });
+    if (repoType === undefined)
         return 1;
-    printStep('Detecting repo type');
-    let repoType;
-    try {
-        repoType = detectRepoType();
-    }
-    catch (error) {
-        if (!isAnticipatedFailure(error)) {
-            throw error;
-        }
-        printError(`Failed to detect repo type: ${describeError(error)}`, styles.stderr);
-        return 1;
-    }
-    printSuccess(`Detected: ${repoType}`, styles.stdout);
     printStep('Updating workflows');
     let results;
     try {
@@ -65,17 +37,12 @@ function buildManagedFiles(repoType, publishable) {
         ? []
         : PUBLISHING_WORKFLOW_PATHS.filter((filePath) => !existsSync(filePath));
     const files = [
-        [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, renderCreateGithubReleaseWorkflow(repoType)],
-        [PUBLISH_WORKFLOW_PATH, renderPublishWorkflow(repoType, { shouldGenerateProvenance: readProvenanceSetting() })],
-        ['.github/workflows/release.yaml', renderReleaseWorkflow(repoType)],
+        [CREATE_GITHUB_RELEASE_WORKFLOW_PATH, renderExpectedCreateGithubReleaseWorkflow(repoType)],
+        [PUBLISH_WORKFLOW_PATH, renderExpectedPublishWorkflow(repoType)],
+        ['.github/workflows/release.yaml', renderExpectedReleaseWorkflow(repoType)],
     ];
     if (existsSync(SYNC_LABELS_WORKFLOW_PATH)) {
         files.push([SYNC_LABELS_WORKFLOW_PATH, readSyncLabelsWorkflowTemplate()]);
     }
     return { files: files.filter(([filePath]) => !skippedPaths.includes(filePath)), skippedPaths };
 }
-function readProvenanceSetting() {
-    if (!existsSync(PUBLISH_WORKFLOW_PATH))
-        return true;
-    return hasProvenance(readFileSync(PUBLISH_WORKFLOW_PATH, 'utf8'));
-}

package/dist/esm/injectReleaseNotesIntoReadme.d.ts

@@ -34,19 +34,41 @@ export type RenderInjectedReadmeResult = {
  * function has derived it from the tag.
  */
 export declare function renderInjectedReadmeFromEntries(readme: string, entries: readonly ChangelogEntry[], tag: string, sectionOrder?: string[]): RenderInjectedReadmeResult;
+/** Why `renderInjectedReadme` did not render a README, with the version when the reason concerns one. */
+export type ReadmeInjectionSkip = {
+    reason: 'missing-file' | 'unreadable-file';
+} | {
+    reason: RenderInjectedReadmeSkipReason;
+    version: string;
+};
+/** Discriminated outcome of rendering release notes from a saved `changelog.json`. */
+export type RenderInjectedReadmeFromFileResult = {
+    status: 'rendered';
+    renderedReadme: RenderedInjectedReadme;
+} | {
+    status: 'skipped';
+    skip: ReadmeInjectionSkip;
+};
+/** Discriminated outcome of injecting release notes into a README file. */
+export type InjectReleaseNotesResult = {
+    status: 'injected';
+    originalReadme: string;
+} | {
+    status: 'skipped';
+    skip: ReadmeInjectionSkip;
+};
 /**
  * Path-taking wrapper over {@link renderInjectedReadmeFromEntries} for callers rendering from a
  * saved `changelog.json`, such as the publish-time injection flow.
  *
- * Adds the two skip conditions that only a file can present: The changelog is missing, or it does
- * not parse. Warns on every skip, its own and the renderer's alike, because the publish path does
- * not have any other channel for the message.
+ * Adds the two skip conditions that only a file can present: The changelog is missing, or it cannot
+ * be read as entries.
  */
-export declare function renderInjectedReadme(readme: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): RenderedInjectedReadme | undefined;
+export declare function renderInjectedReadme(readme: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): RenderInjectedReadmeFromFileResult;
 /**
- * Injects release notes into a README file, returning the original content for restoration, or `undefined` when
- * injection was skipped.
+ * Injects release notes into a README file, returning the original content for restoration, or the skip when
+ * injection did not happen.
  */
-export declare function injectReleaseNotesIntoReadme(readmePath: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): string | undefined;
+export declare function injectReleaseNotesIntoReadme(readmePath: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): InjectReleaseNotesResult;
 /** Returns the path of a workspace's `README.md`, or `undefined` when it has none. */
 export declare function resolveReadmePath(workspacePath: string): string | undefined;