@codefast/cli 0.10.0 → 0.11.0

package/dist/mirror/prepare.js

@@ -1,8 +1,6 @@
+import { resolveProjectRootResult } from "#/core/cli/resolve-root";
 import { loadCodefastConfig } from "#/core/config";
-import { AppError } from "#/core/errors";
-import { messageFrom } from "#/core/errors";
-import { err, ok } from "#/core/result";
-import { resolveProjectRoot } from "#/core/workspace/resolver";
+import { ok } from "#/core/result";
 import { resolveMirrorPackageFromCliArg } from "#/mirror/package-path";
 /**
  * Resolves the repo root, config, and package filter into the prelude a mirror run starts from.
@@ -10,13 +8,11 @@ import { resolveMirrorPackageFromCliArg } from "#/mirror/package-path";
  * @since 0.3.16-canary.0
  */
 export async function prepareMirrorSync(fs, args) {
-    let rootDir;
-    try {
-        rootDir = resolveProjectRoot(args.currentWorkingDirectory, fs).rootDir;
-    }
-    catch (caughtError) {
-        return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+    const rootOutcome = resolveProjectRootResult(fs, args.currentWorkingDirectory);
+    if (!rootOutcome.ok) {
+        return rootOutcome;
     }
+    const rootDir = rootOutcome.value;
     const filterOutcome = resolveMirrorPackageFromCliArg(fs, {
         rootDir,
         packageArg: args.packageArg,

package/dist/mirror/run.d.ts

@@ -0,0 +1,12 @@
+import { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+import type { GlobalStats } from "#/mirror/domain/types";
+import type { MirrorSyncExecutionInput } from "#/mirror/domain/types";
+export type { MirrorSyncExecutionInput } from "#/mirror/domain/types";
+/**
+ * Runs the mirror sync across the targeted packages and returns the aggregate stats.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runMirrorSync(fs: Filesystem, input: MirrorSyncExecutionInput): Promise<Result<GlobalStats, AppError>>;

package/dist/mirror/supplement-exports.d.ts

@@ -1,4 +1,4 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#/core/filesystem/filesystem";
 /**
  * The export specifiers a preserve-mode run added conditions to.
  *
@@ -12,7 +12,7 @@ export type SupplementResult = {
  *
  * @since 0.3.16-canary.0
  */
-export declare function supplementExportsInPackageJson(fs: FilesystemPort, packageJsonPath: string, packageDir: string, options: {
+export declare function supplementExportsInPackageJson(fs: Filesystem, packageJsonPath: string, packageDir: string, options: {
     source: boolean | string;
     types: boolean;
     import: boolean;
@@ -24,4 +24,4 @@ export declare function supplementExportsInPackageJson(fs: FilesystemPort, packa
  *
  * @since 0.3.16-canary.0
  */
-export declare function buildSourcePathResolver(fs: FilesystemPort, packageDir: string): (modulePath: string) => string;
+export declare function buildSourcePathResolver(fs: Filesystem, packageDir: string): (modulePath: string) => string;

package/dist/mirror/sync-workspace-package.d.ts

@@ -1,9 +1,9 @@
 import type { MirrorConfig } from "#/core/config/schema";
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#/core/filesystem/filesystem";
 import type { PackageStats } from "#/mirror/domain/types";
 /**
  * Regenerates one package's `package.json#exports` from its `dist/` and returns the package's stats.
  *
  * @since 0.3.16-canary.0
  */
-export declare function syncExportsForWorkspacePackage(fs: FilesystemPort, rootDir: string, packagePathStr: string, config: MirrorConfig, write?: boolean): Promise<PackageStats>;
+export declare function syncExportsForWorkspacePackage(fs: Filesystem, rootDir: string, packagePathStr: string, config: MirrorConfig, write?: boolean): Promise<PackageStats>;

package/dist/mirror/sync-workspace-package.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { messageFrom } from "#/core/errors";
 import { distDirName, packageJsonFileName } from "#/core/workspace/well-known-files";
-import { createMirrorDistFilesystem } from "#/mirror/dist-filesystem-impl";
+import { createMirrorDistFilesystem } from "#/mirror/dist-filesystem-node";
 import { createPathTransform, generateExports } from "#/mirror/domain/exports";
 import { resolvePackageDisplayName } from "#/mirror/domain/package-display-name";
 import { buildSourcePathResolver, supplementExportsInPackageJson } from "#/mirror/supplement-exports";

package/dist/mirror/write-exports.d.ts

@@ -1,4 +1,4 @@
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#/core/filesystem/filesystem";
 import type { ExportMapData, ExportOriginalPathBySpecifier } from "#/mirror/domain/types";
 /**
  * Writes `exports` into `package.json` via a temp file + rename (atomic on same volume).
@@ -6,7 +6,7 @@ import type { ExportMapData, ExportOriginalPathBySpecifier } from "#/mirror/doma
  *
  * @since 0.3.16-canary.0
  */
-export declare function writePackageJsonExportsAtomic(fs: FilesystemPort, packageJsonPath: string, mergeInput: {
+export declare function writePackageJsonExportsAtomic(fs: Filesystem, packageJsonPath: string, mergeInput: {
     generatedExports: ExportMapData;
     managedExportSpecifiers: Array<string>;
     originalPathBySpecifier: ExportOriginalPathBySpecifier;

package/dist/pack-slim/cli-schema.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * The validated serializable inputs of a pack-slim run.
  *

package/dist/pack-slim/cli-schema.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * Zod schema validating the serializable inputs of a pack-slim run.
  *

package/dist/pack-slim/command.js

@@ -1,80 +1,45 @@
-import process from "node:process";
 import { Command } from "commander";
-import { globalCliCommanderOptionsSchema } from "#/core/cli/global-options";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError } from "#/core/cli/result-handle";
-import { AppError, messageFrom } from "#/core/errors";
+import { applyCommandPipeline } from "#/core/cli/command-pipeline";
 import { nodeFilesystem } from "#/core/filesystem/node";
-import { logger } from "#/core/logger";
-import { err } from "#/core/result";
-import { parseWithSchema } from "#/core/schema-parse";
-import { resolveProjectRoot } from "#/core/workspace/resolver";
+import { ok } from "#/core/result";
 import { exitCodeForPackSlimResult, formatPackSlimJsonOutput } from "#/pack-slim/cli-result";
 import { packSlimRunRequestSchema } from "#/pack-slim/cli-schema";
 import { PackSlimProgressPresenter } from "#/pack-slim/output";
-import { runPackSlim } from "#/pack-slim/sync";
+import { preparePackSlim } from "#/pack-slim/prepare";
+import { runPackSlim } from "#/pack-slim/run";
 import { ensureWorkingTreeClean } from "#/pack-slim/working-tree";
+const packSlimPipeline = {
+    positional: { name: "[package]", help: "Optional package path relative to repo root (e.g. packages/ui)" },
+    schema: packSlimRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Report what would change without touching any file", false);
+        command.option("--force", "Run even if the git working tree has uncommitted tracked changes", false);
+    },
+    prepare: (fs, input) => preparePackSlim(fs, { currentWorkingDirectory: input.currentWorkingDirectory, packageArg: input.rawArg }),
+    // A destructive slim must never land on uncommitted work; --dry-run writes nothing, so it is exempt.
+    guard: async ({ prelude, opts }) => !opts.dryRun && !opts.force ? ensureWorkingTreeClean(prelude.rootDir) : ok(undefined),
+    buildRequest: ({ prelude, opts }) => ({
+        rootDir: prelude.rootDir,
+        packageFilter: prelude.packageFilter,
+        write: !opts.dryRun,
+    }),
+    createPresenter: ({ opts }) => {
+        const presenter = new PackSlimProgressPresenter();
+        presenter.configure({ dryRun: !!opts.dryRun });
+        return presenter;
+    },
+    run: (fs, request, presenter) => runPackSlim(fs, { ...request, listener: presenter }),
+    formatJson: ({ result, opts, elapsedSeconds }) => formatPackSlimJsonOutput(result, elapsedSeconds, !opts.dryRun),
+    exitCode: exitCodeForPackSlimResult,
+};
 /**
  * Creates the `pack-slim` subcommand, which slims published packages down to what a consumer reads before publish.
  *
  * @since 0.8.1
  */
 export function createPackSlimCommand() {
-    const cmd = new Command("pack-slim")
-        .description("Strip src, source conditions, unshipped imports, dev-only scripts, devDependencies, and dist source maps from " +
-        "published packages before publish")
-        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
-        .option("--dry-run", "Report what would change without touching any file", false)
-        .option("--force", "Run even if the git working tree has uncommitted tracked changes", false)
-        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
-        .action(async (packageArg, opts, command) => {
-        const globalsOptionCarrier = command.optsWithGlobals?.() ??
-            command.opts();
-        const globalOptionsOutcome = parseWithSchema(globalCliCommanderOptionsSchema, globalsOptionCarrier);
-        if (!consumeCliAppError(globalOptionsOutcome)) {
-            return;
-        }
-        let rootDir;
-        try {
-            rootDir = resolveProjectRoot(process.cwd(), nodeFilesystem).rootDir;
-        }
-        catch (caughtError) {
-            consumeCliAppError(err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError)));
-            return;
-        }
-        const write = !opts.dryRun;
-        // A destructive slim must never land on a developer's uncommitted work; --dry-run writes nothing, so it is exempt.
-        if (write && !opts.force) {
-            const cleanCheck = ensureWorkingTreeClean(rootDir);
-            if (!consumeCliAppError(cleanCheck)) {
-                return;
-            }
-        }
-        const parsed = parseWithSchema(packSlimRunRequestSchema, {
-            rootDir,
-            packageFilter: readOptionalPositionalArg(packageArg),
-            write,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const json = !!opts.json;
-        const presenter = new PackSlimProgressPresenter();
-        if (!json) {
-            presenter.configure({ dryRun: !write });
-        }
-        const startTime = performance.now();
-        const outcome = await runPackSlim(nodeFilesystem, {
-            ...parsed.value,
-            listener: json ? undefined : presenter,
-        });
-        if (!consumeCliAppError(outcome)) {
-            return;
-        }
-        if (json) {
-            logger.out(formatPackSlimJsonOutput(outcome.value, (performance.now() - startTime) / 1000, write));
-        }
-        process.exitCode = exitCodeForPackSlimResult(outcome.value);
-    });
+    const cmd = new Command("pack-slim").description("Strip src, source conditions, unshipped imports, dev-only scripts, devDependencies, and dist source maps from " +
+        "published packages before publish");
+    applyCommandPipeline(cmd, nodeFilesystem, packSlimPipeline);
     return cmd;
 }

package/dist/pack-slim/prepare.d.ts

@@ -0,0 +1,21 @@
+import type { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * The repo root and package filter a pack-slim run starts from.
+ *
+ * @since 0.8.1
+ */
+export interface PackSlimCommandPrelude {
+    readonly rootDir: string;
+    readonly packageFilter: string | undefined;
+}
+/**
+ * Resolves the repo root and optional package filter into the prelude a pack-slim run starts from.
+ *
+ * @since 0.8.1
+ */
+export declare function preparePackSlim(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly packageArg: string | undefined;
+}): Promise<Result<PackSlimCommandPrelude, AppError>>;

package/dist/pack-slim/prepare.js

@@ -0,0 +1,14 @@
+import { resolveProjectRootResult } from "#/core/cli/resolve-root";
+import { ok } from "#/core/result";
+/**
+ * Resolves the repo root and optional package filter into the prelude a pack-slim run starts from.
+ *
+ * @since 0.8.1
+ */
+export async function preparePackSlim(fs, args) {
+    const rootOutcome = resolveProjectRootResult(fs, args.currentWorkingDirectory);
+    if (!rootOutcome.ok) {
+        return rootOutcome;
+    }
+    return ok({ rootDir: rootOutcome.value, packageFilter: args.packageArg });
+}

package/dist/pack-slim/{sync.d.ts → run.d.ts}

@@ -1,5 +1,5 @@
 import { AppError } from "#/core/errors";
-import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Filesystem } from "#/core/filesystem/filesystem";
 import type { Result } from "#/core/result";
 import type { PackSlimRunRequest } from "#/pack-slim/cli-schema";
 import type { PackSlimProgressListener, PackSlimRunStats } from "#/pack-slim/domain/types";
@@ -20,4 +20,4 @@ export type PackSlimRunInput = PackSlimRunRequest & {
  *
  * @since 0.8.1
  */
-export declare function runPackSlim(fs: FilesystemPort, input: PackSlimRunInput): Promise<Result<PackSlimRunStats, AppError>>;
+export declare function runPackSlim(fs: Filesystem, input: PackSlimRunInput): Promise<Result<PackSlimRunStats, AppError>>;

package/dist/tag/cli-result.d.ts

@@ -1,7 +1,13 @@
-import type { TagSyncResult } from "#/tag/domain/types";
+import type { TagResult } from "#/tag/domain/types";
 /**
  * Maps a tag run's result to the process exit code.
  *
  * @since 0.3.16-canary.0
  */
-export declare function exitCodeForTagSyncResult(result: TagSyncResult): number;
+export declare function exitCodeForTagResult(result: TagResult): number;
+/**
+ * Serializes a tag run's result as the `--json` output string.
+ *
+ * @since 0.11.0
+ */
+export declare function formatTagJsonOutput(result: TagResult, rootDir: string): string;

package/dist/tag/cli-result.js

@@ -4,10 +4,23 @@ import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
  *
  * @since 0.3.16-canary.0
  */
-export function exitCodeForTagSyncResult(result) {
+export function exitCodeForTagResult(result) {
     if (result.selectedTargets.length === 0) {
         return CLI_EXIT_GENERAL_ERROR;
     }
     const hasRunErrors = result.targetResults.some((targetResult) => targetResult.runError !== null);
     return hasRunErrors || result.hookError !== null ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
+}
+/**
+ * Serializes a tag run's result as the `--json` output string.
+ *
+ * @since 0.11.0
+ */
+export function formatTagJsonOutput(result, rootDir) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        ok: result.hookError === null,
+        cwd: rootDir,
+        result,
+    });
 }

package/dist/tag/cli-schema.d.ts

@@ -1,8 +1,8 @@
-import { z } from "zod";
-import type { TagSyncRunRequest } from "#/tag/sync";
+import * as z from "zod";
+import type { TagRunRequest } from "#/tag/domain/types";
 /**
- * Zod schema validating a `TagSyncRunRequest`.
+ * Zod schema validating a `TagRunRequest`.
  *
  * @since 0.3.16-canary.0
  */
-export declare const tagSyncRunRequestSchema: z.ZodType<TagSyncRunRequest>;
+export declare const tagRunRequestSchema: z.ZodType<TagRunRequest>;

package/dist/tag/cli-schema.js

@@ -1,13 +1,12 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
- * Zod schema validating a `TagSyncRunRequest`.
+ * Zod schema validating a `TagRunRequest`.
  *
  * @since 0.3.16-canary.0
  */
-export const tagSyncRunRequestSchema = z.object({
+export const tagRunRequestSchema = z.object({
     rootDir: z.string().min(1),
     write: z.boolean(),
-    json: z.boolean().optional(),
     targetPath: z.string().optional(),
     skipPackages: z.array(z.string()).optional(),
     config: z.unknown().optional(),

package/dist/tag/command.js

@@ -1,70 +1,43 @@
-import process from "node:process";
 import { Command } from "commander";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError } from "#/core/cli/result-handle";
+import { applyCommandPipeline } from "#/core/cli/command-pipeline";
 import { nodeFilesystem } from "#/core/filesystem/node";
-import { logger } from "#/core/logger";
-import { parseWithSchema } from "#/core/schema-parse";
-import { exitCodeForTagSyncResult } from "#/tag/cli-result";
-import { tagSyncRunRequestSchema } from "#/tag/cli-schema";
-import { presentTagSyncResult, TagSyncProgressPresenter } from "#/tag/output";
-import { prepareTagSync } from "#/tag/prepare";
-import { runTagSync } from "#/tag/sync";
+import { exitCodeForTagResult, formatTagJsonOutput } from "#/tag/cli-result";
+import { tagRunRequestSchema } from "#/tag/cli-schema";
+import { presentTagResult, TagProgressPresenter } from "#/tag/output";
+import { prepareTag } from "#/tag/prepare";
+import { runTag } from "#/tag/run";
+const tagPipeline = {
+    positional: { name: "[target]", help: "Directory or file to tag (default: auto-discover workspace packages)" },
+    schema: tagRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Show summary without writing files", false);
+    },
+    prepare: (fs, input) => prepareTag(fs, { currentWorkingDirectory: input.currentWorkingDirectory, rawTarget: input.rawArg }),
+    buildRequest: ({ prelude, opts }) => {
+        const tagConfig = prelude.config.tag ?? {};
+        return {
+            rootDir: prelude.rootDir,
+            write: !opts.dryRun,
+            targetPath: prelude.resolvedTargetPath,
+            skipPackages: tagConfig.skipPackages,
+            config: tagConfig,
+        };
+    },
+    createPresenter: () => new TagProgressPresenter(),
+    run: (fs, request, presenter) => runTag(fs, { ...request, listener: presenter }),
+    presentHuman: ({ result, prelude }) => {
+        presentTagResult(result, prelude.rootDir);
+    },
+    formatJson: ({ result, prelude }) => formatTagJsonOutput(result, prelude.rootDir),
+    exitCode: exitCodeForTagResult,
+};
 /**
  * Creates the `tag` subcommand, which stamps `@since` tags on exported declarations.
  *
  * @since 0.3.16-canary.0
  */
 export function createTagCommand() {
-    const cmd = new Command("tag")
-        .description("Add @since <version> JSDoc tags to exported declarations")
-        .argument("[target]", "Directory or file to tag (default: auto-discover workspace packages)")
-        .option("--dry-run", "Show summary without writing files", false)
-        .option("--json", "Print one JSON summary on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const prelude = await prepareTagSync(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { rootDir, config, resolvedTargetPath } = prelude.value;
-        const tagConfig = config.tag ?? {};
-        const parsed = parseWithSchema(tagSyncRunRequestSchema, {
-            rootDir,
-            write: !opts.dryRun,
-            json: opts.json,
-            targetPath: resolvedTargetPath,
-            skipPackages: tagConfig.skipPackages,
-            config: tagConfig,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const progressPresenter = new TagSyncProgressPresenter();
-        const tagOutcome = await runTagSync(nodeFilesystem, {
-            ...parsed.value,
-            listener: parsed.value.json ? undefined : progressPresenter,
-        });
-        if (!consumeCliAppError(tagOutcome)) {
-            return;
-        }
-        if (parsed.value.json) {
-            logger.out(formatTagSyncJsonOutput(tagOutcome.value, rootDir));
-            process.exitCode = exitCodeForTagSyncResult(tagOutcome.value);
-        }
-        else {
-            process.exitCode = presentTagSyncResult(tagOutcome.value, rootDir);
-        }
-    });
+    const cmd = new Command("tag").description("Add @since <version> JSDoc tags to exported declarations");
+    applyCommandPipeline(cmd, nodeFilesystem, tagPipeline);
     return cmd;
-}
-function formatTagSyncJsonOutput(result, rootDir) {
-    return JSON.stringify({
-        schemaVersion: 1,
-        ok: result.hookError === null,
-        cwd: rootDir,
-        result,
-    });
 }

package/dist/tag/domain/skip-filter.d.ts

@@ -0,0 +1,13 @@
+import type { TagTargetCandidate } from "#/tag/domain/types";
+/**
+ * Partitions tag target candidates into those to tag and those to skip, matching each candidate's
+ * package name against `skipPackages` as glob patterns.
+ *
+ * @remarks Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export declare function filterSkippedCandidates(targetCandidates: Array<TagTargetCandidate>, skipPackages: ReadonlyArray<string> | undefined): {
+    includedCandidates: Array<TagTargetCandidate>;
+    skippedPackages: Array<string>;
+};

package/dist/tag/domain/skip-filter.js

@@ -0,0 +1,29 @@
+import { createAnyGlobMatcher } from "#/core/glob";
+/**
+ * Partitions tag target candidates into those to tag and those to skip, matching each candidate's
+ * package name against `skipPackages` as glob patterns.
+ *
+ * @remarks Candidates without a package name (e.g. an explicit-target path) are never skipped.
+ *
+ * @since 0.5.0-canary.0
+ */
+export function filterSkippedCandidates(targetCandidates, skipPackages) {
+    if (!skipPackages || skipPackages.length === 0) {
+        return {
+            includedCandidates: targetCandidates,
+            skippedPackages: [],
+        };
+    }
+    const isSkipped = createAnyGlobMatcher(skipPackages);
+    const includedCandidates = [];
+    const skippedPackages = [];
+    for (const candidate of targetCandidates) {
+        const packageName = candidate.packageName;
+        if (packageName && isSkipped(packageName)) {
+            skippedPackages.push(packageName);
+            continue;
+        }
+        includedCandidates.push(candidate);
+    }
+    return { includedCandidates, skippedPackages };
+}

package/dist/tag/domain/types.d.ts

@@ -85,7 +85,7 @@ export interface TagProgressListener {
  *
  * @since 0.3.16-canary.0
  */
-export type TagSyncResult = {
+export type TagResult = {
     mode: "applied" | "dry-run";
     selectedTargets: Array<TagResolvedTarget>;
     skippedPackages: Array<string>;
@@ -108,4 +108,24 @@ export interface TagCommandPrelude {
     readonly config: CodefastConfig;
     readonly resolvedTargetPath: string | undefined;
 }
+/**
+ * The inputs a tag run is invoked with.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagRunRequest = {
+    rootDir: string;
+    write: boolean;
+    targetPath?: string | undefined;
+    skipPackages?: Array<string> | undefined;
+    config?: unknown;
+};
+/**
+ * A run request paired with an optional progress listener.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TagExecutionInput = TagRunRequest & {
+    readonly listener?: TagProgressListener | undefined;
+};
 export {};

package/dist/tag/domain/version-summary.d.ts

@@ -0,0 +1,13 @@
+import type { TagTargetExecutionResult } from "#/tag/domain/types";
+/**
+ * Collects the distinct, non-empty package versions stamped across a run's target results.
+ *
+ * @since 0.11.0
+ */
+export declare function extractDistinctVersions(targetResults: Array<TagTargetExecutionResult>): Set<string>;
+/**
+ * Summarizes a set of versions as `"none"`, the single version, or `"mixed"`.
+ *
+ * @since 0.11.0
+ */
+export declare function summarizeVersions(distinctVersions: Set<string>): string;

package/dist/tag/domain/version-summary.js

@@ -0,0 +1,24 @@
+/**
+ * Collects the distinct, non-empty package versions stamped across a run's target results.
+ *
+ * @since 0.11.0
+ */
+export function extractDistinctVersions(targetResults) {
+    return new Set(targetResults
+        .map((targetResult) => targetResult.result?.version)
+        .filter((version) => typeof version === "string" && version.length > 0));
+}
+/**
+ * Summarizes a set of versions as `"none"`, the single version, or `"mixed"`.
+ *
+ * @since 0.11.0
+ */
+export function summarizeVersions(distinctVersions) {
+    if (distinctVersions.size === 0) {
+        return "none";
+    }
+    if (distinctVersions.size > 1) {
+        return "mixed";
+    }
+    return distinctVersions.values().next().value ?? "none";
+}

package/dist/tag/output.d.ts

@@ -1,17 +1,17 @@
-import type { TagProgressListener, TagResolvedTarget, TagSyncResult, TagTargetExecutionResult } from "#/tag/domain/types";
+import type { TagProgressListener, TagResolvedTarget, TagResult, TagTargetExecutionResult } from "#/tag/domain/types";
 /**
  * A progress listener that prints a line as each tag target starts and completes.
  *
  * @since 0.3.16-canary.0
  */
-export declare class TagSyncProgressPresenter implements TagProgressListener {
+export declare class TagProgressPresenter implements TagProgressListener {
     onTargetStarted(target: TagResolvedTarget): void;
     onTargetCompleted(target: TagResolvedTarget, result: TagTargetExecutionResult): void;
     private static formatProgress;
 }
 /**
- * Prints a tag run's target table, warnings, and summary, and returns the exit code.
+ * Prints a tag run's target table, warnings, and summary to the human reader.
  *
  * @since 0.3.16-canary.0
  */
-export declare function presentTagSyncResult(result: TagSyncResult, rootDir: string): number;
+export declare function presentTagResult(result: TagResult, rootDir: string): void;

package/dist/tag/output.js

@@ -1,17 +1,15 @@
-import { CLI_EXIT_GENERAL_ERROR } from "#/core/exit-codes";
 import { logger } from "#/core/logger";
-import { exitCodeForTagSyncResult } from "#/tag/cli-result";
 /**
  * A progress listener that prints a line as each tag target starts and completes.
  *
  * @since 0.3.16-canary.0
  */
-export class TagSyncProgressPresenter {
+export class TagProgressPresenter {
     onTargetStarted(target) {
-        logger.out(TagSyncProgressPresenter.formatProgress({ type: "target-started", target }));
+        logger.out(TagProgressPresenter.formatProgress({ type: "target-started", target }));
     }
     onTargetCompleted(target, result) {
-        logger.out(TagSyncProgressPresenter.formatProgress({ type: "target-completed", target, result }));
+        logger.out(TagProgressPresenter.formatProgress({ type: "target-completed", target, result }));
     }
     static formatProgress(event) {
         const targetDisplayName = (target) => target.packageName ?? target.rootRelativeTargetPath;
@@ -29,22 +27,21 @@ const colors = {
     yellow: "\x1b[33m",
 };
 /**
- * Prints a tag run's target table, warnings, and summary, and returns the exit code.
+ * Prints a tag run's target table, warnings, and summary to the human reader.
  *
  * @since 0.3.16-canary.0
  */
-export function presentTagSyncResult(result, rootDir) {
+export function presentTagResult(result, rootDir) {
     logger.out(formatTargetTable(result.selectedTargets, rootDir));
     if (result.selectedTargets.length === 0) {
         logger.err("No packages found in workspace. Check your pnpm-workspace.yaml or provide an explicit target path.");
-        return CLI_EXIT_GENERAL_ERROR;
+        return;
     }
     const warningsAndErrorsSection = formatWarningsAndErrors(result);
     if (warningsAndErrorsSection) {
         logger.err(warningsAndErrorsSection);
     }
     logger.out(formatSummary(result));
-    return exitCodeForTagSyncResult(result);
 }
 function withColorizedLine(line, colorCode) {
     return `${colorCode}${line}${colorReset}`;