@codefast/cli 0.3.13-canary.1 → 0.3.13-canary.3

package/dist/lib/mirror/infra/update-pkg.adapter.js

@@ -0,0 +1,156 @@
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+import { MirrorError, MirrorErrorCode } from "#lib/mirror/domain/errors.domain";
+import { PACKAGE_JSON_EXPORT } from "#lib/mirror/domain/constants.domain";
+function containsDistTarget(value) {
+    if (typeof value === "string") {
+        return value.startsWith("./dist/");
+    }
+    if (Array.isArray(value)) {
+        return value.some((entryValue) => containsDistTarget(entryValue));
+    }
+    if (value && typeof value === "object") {
+        return Object.values(value).some((entryValue) => containsDistTarget(entryValue));
+    }
+    return false;
+}
+/**
+ * Keep `./package.json` at the very end for aesthetics by default.
+ * If a catch-all `./*` exists, move `./package.json` before wildcards so it remains reachable.
+ */
+function exportSpecifierRank(exportSpecifier, hasCatchAllWildcard) {
+    if (exportSpecifier === ".") {
+        return 0;
+    }
+    if (exportSpecifier === PACKAGE_JSON_EXPORT) {
+        return hasCatchAllWildcard ? 2 : 4;
+    }
+    if (exportSpecifier.includes("*")) {
+        return 3;
+    }
+    return 1;
+}
+function compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySpecifier, hasCatchAllWildcard) {
+    const leftRank = exportSpecifierRank(leftSpecifier, hasCatchAllWildcard);
+    const rightRank = exportSpecifierRank(rightSpecifier, hasCatchAllWildcard);
+    if (leftRank !== rightRank) {
+        return leftRank - rightRank;
+    }
+    const leftOriginalPath = originalPathBySpecifier[leftSpecifier] ?? leftSpecifier;
+    const rightOriginalPath = originalPathBySpecifier[rightSpecifier] ?? rightSpecifier;
+    const originalPathComparison = leftOriginalPath.localeCompare(rightOriginalPath);
+    if (originalPathComparison !== 0) {
+        return originalPathComparison;
+    }
+    return leftSpecifier.localeCompare(rightSpecifier);
+}
+/** Shared rule: show `package.json#name` when it is a non-empty string; else folder basename. */
+export function resolvePackageDisplayName(packageJson, folderBasename) {
+    const declaredName = packageJson.name;
+    return typeof declaredName === "string" && declaredName.length > 0
+        ? declaredName
+        : folderBasename;
+}
+export async function readPackageJsonDisplayName(fs, packageJsonPath, folderBasename) {
+    if (!fs.existsSync(packageJsonPath)) {
+        return folderBasename;
+    }
+    try {
+        const raw = await fs.readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return resolvePackageDisplayName(parsed, folderBasename);
+    }
+    catch {
+        return folderBasename;
+    }
+}
+/**
+ * Writes `exports` into `package.json` via a temp file + rename (atomic on same volume).
+ * Preserves a trailing newline after JSON.
+ */
+export async function writePackageJsonExportsAtomic(fs, packageJsonPath, mergeInput) {
+    const raw = await fs.readFile(packageJsonPath, "utf8");
+    const packageJson = JSON.parse(raw);
+    const existingExports = packageJson.exports;
+    const existingExportMap = existingExports && typeof existingExports === "object" && !Array.isArray(existingExports)
+        ? existingExports
+        : {};
+    const managedSpecifiers = new Set(mergeInput.managedExportSpecifiers);
+    const originalPathBySpecifier = {
+        ...mergeInput.originalPathBySpecifier,
+    };
+    const mergedExportMap = {};
+    const prunedKeys = [];
+    // Preserve unmanaged manual entries; drop unmanaged stale entries targeting dist/.
+    for (const [exportSpecifier, exportValue] of Object.entries(existingExportMap)) {
+        if (exportSpecifier === PACKAGE_JSON_EXPORT) {
+            mergedExportMap[exportSpecifier] = exportValue;
+            if (!(exportSpecifier in originalPathBySpecifier)) {
+                originalPathBySpecifier[exportSpecifier] = exportSpecifier;
+            }
+            continue;
+        }
+        if (!managedSpecifiers.has(exportSpecifier)) {
+            if (containsDistTarget(exportValue)) {
+                prunedKeys.push(exportSpecifier);
+            }
+            else {
+                mergedExportMap[exportSpecifier] = exportValue;
+                if (!(exportSpecifier in originalPathBySpecifier)) {
+                    originalPathBySpecifier[exportSpecifier] = exportSpecifier;
+                }
+            }
+        }
+    }
+    // Generated entries always win for managed specifiers (including ".").
+    for (const [exportSpecifier, exportValue] of Object.entries(mergeInput.generatedExports)) {
+        mergedExportMap[exportSpecifier] = exportValue;
+    }
+    if (!(PACKAGE_JSON_EXPORT in mergedExportMap)) {
+        mergedExportMap[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+    }
+    originalPathBySpecifier[PACKAGE_JSON_EXPORT] = PACKAGE_JSON_EXPORT;
+    const rootExport = mergedExportMap["."];
+    if (rootExport && typeof rootExport === "object" && !Array.isArray(rootExport)) {
+        const rootEntry = rootExport;
+        const requirePath = typeof rootEntry.require === "string" ? rootEntry.require : undefined;
+        const importPath = typeof rootEntry.import === "string" ? rootEntry.import : undefined;
+        const typesPath = typeof rootEntry.types === "string" ? rootEntry.types : undefined;
+        if (requirePath || importPath) {
+            packageJson.main = requirePath ?? importPath;
+        }
+        if (importPath && importPath.endsWith(".mjs")) {
+            packageJson.module = importPath;
+        }
+        if (typesPath) {
+            packageJson.types = typesPath;
+        }
+    }
+    const filesField = packageJson.files;
+    if (Array.isArray(filesField)) {
+        const normalizedFiles = filesField.filter((entry) => typeof entry === "string");
+        if (!normalizedFiles.includes("dist")) {
+            normalizedFiles.push("dist");
+        }
+        packageJson.files = normalizedFiles;
+    }
+    else {
+        packageJson.files = ["dist"];
+    }
+    const sortedExportMap = {};
+    const hasCatchAllWildcard = "./*" in mergedExportMap;
+    for (const exportSpecifier of Object.keys(mergedExportMap).sort((leftSpecifier, rightSpecifier) => compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySpecifier, hasCatchAllWildcard))) {
+        sortedExportMap[exportSpecifier] = mergedExportMap[exportSpecifier];
+    }
+    packageJson.exports = sortedExportMap;
+    const serialized = JSON.stringify(packageJson, null, 2) + "\n";
+    const tmpPath = `${packageJsonPath}.tmp`;
+    await fs.writeFile(tmpPath, serialized, "utf8");
+    try {
+        await fs.rename(tmpPath, packageJsonPath);
+    }
+    catch (caughtRenameError) {
+        await fs.unlink(tmpPath).catch(() => { });
+        throw new MirrorError(MirrorErrorCode.PACKAGE_WRITE, `Failed to atomically update ${packageJsonPath}: ${messageFromCaughtUnknown(caughtRenameError)}`, caughtRenameError instanceof Error ? { cause: caughtRenameError } : undefined);
+    }
+    return { prunedKeys };
+}

package/dist/lib/mirror/infra/workspace-packages.adapter.d.ts

@@ -0,0 +1,26 @@
+import type { CliFs, CliLogger } from "#lib/infra/fs-contract.port";
+import type { FindWorkspacePackagesResult } from "#lib/mirror/domain/types.domain";
+/** Turn a pnpm `packages` glob into a `globSync` pattern that finds `package.json` files. */
+export declare function workspacePatternToPackageJsonGlob(pattern: string): string;
+export declare function splitWorkspacePackageEntries(raw: unknown): {
+    include: string[];
+    exclude: string[];
+};
+/**
+ * Reads `packages` from a parsed pnpm workspace document.
+ * @throws If the document is invalid or `packages` is present but not an array.
+ */
+export declare function parsePnpmWorkspaceDocument(doc: unknown): {
+    include: string[];
+    exclude: string[];
+    hasPackagesKey: boolean;
+    /** True only when `packages` exists and the YAML array is literally `[]`. */
+    isEmptyPackagesArray: boolean;
+};
+/**
+ * Workspace package directories relative to `rootDir` (POSIX slashes), sorted.
+ * Reads `pnpm-workspace.yaml` when present; otherwise uses `packages/*`.
+ * Only paths with a `package.json` are returned (same practical rule as pnpm).
+ */
+export declare function findWorkspacePackageRelPaths(rootDir: string, fs: CliFs, logger: CliLogger): Promise<FindWorkspacePackagesResult>;
+//# sourceMappingURL=workspace-packages.adapter.d.ts.map

package/dist/lib/mirror/infra/workspace-packages.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-packages.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/mirror/infra/workspace-packages.adapter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAGpE,OAAO,KAAK,EACV,2BAA2B,EAE5B,MAAM,iCAAiC,CAAC;AAmBzC,6FAA6F;AAC7F,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAMzE;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAqBA;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,OAAO,GAAG;IACxD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,6EAA6E;IAC7E,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CAuBA;AAiCD;;;;GAIG;AACH,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,KAAK,EACT,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAoEtC"}

package/dist/lib/mirror/infra/workspace-packages.adapter.js

@@ -0,0 +1,170 @@
+import { globSync } from "node:fs";
+import path from "node:path";
+import picomatch from "picomatch";
+import { parse as parseYaml } from "yaml";
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+import { normalizePath } from "#lib/mirror/infra/path-normalizer.adapter";
+import { mirrorGlobWarning } from "#lib/mirror/presentation/reporter.presenter";
+const PNPM_WORKSPACE = "pnpm-workspace.yaml";
+/** Default when the workspace file is missing or has no `packages` key. */
+const DEFAULT_INCLUDE = ["packages/*"];
+function toPosix(filePath) {
+    return filePath.split(path.sep).join("/");
+}
+function isGlobPermissionError(caughtError) {
+    if (typeof caughtError !== "object" || caughtError === null || !("code" in caughtError)) {
+        return false;
+    }
+    const code = caughtError.code;
+    return code === "EACCES" || code === "EPERM";
+}
+/** Turn a pnpm `packages` glob into a `globSync` pattern that finds `package.json` files. */
+export function workspacePatternToPackageJsonGlob(pattern) {
+    const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
+    if (!normalizedPattern) {
+        return "**/package.json";
+    }
+    return `${normalizedPattern}/package.json`;
+}
+export function splitWorkspacePackageEntries(raw) {
+    const include = [];
+    const exclude = [];
+    if (!Array.isArray(raw)) {
+        return { include, exclude };
+    }
+    for (const entry of raw) {
+        if (typeof entry !== "string") {
+            continue;
+        }
+        const trimmed = entry.trim();
+        if (!trimmed) {
+            continue;
+        }
+        if (trimmed.startsWith("!")) {
+            exclude.push(trimmed.slice(1).trim());
+        }
+        else {
+            include.push(trimmed);
+        }
+    }
+    return { include, exclude };
+}
+/**
+ * Reads `packages` from a parsed pnpm workspace document.
+ * @throws If the document is invalid or `packages` is present but not an array.
+ */
+export function parsePnpmWorkspaceDocument(doc) {
+    if (doc === null || doc === undefined) {
+        throw new Error(`${PNPM_WORKSPACE} root document must be an object (got empty or null)`);
+    }
+    if (typeof doc !== "object" || Array.isArray(doc)) {
+        throw new Error(`${PNPM_WORKSPACE} root must be a mapping, not an array or scalar`);
+    }
+    const parsedDoc = doc;
+    if (!Object.prototype.hasOwnProperty.call(parsedDoc, "packages")) {
+        return { include: [], exclude: [], hasPackagesKey: false, isEmptyPackagesArray: false };
+    }
+    const pkgs = parsedDoc.packages;
+    if (!Array.isArray(pkgs)) {
+        throw new Error(`${PNPM_WORKSPACE} field "packages" must be an array`);
+    }
+    if (pkgs.length === 0) {
+        return { include: [], exclude: [], hasPackagesKey: true, isEmptyPackagesArray: true };
+    }
+    return {
+        ...splitWorkspacePackageEntries(pkgs),
+        hasPackagesKey: true,
+        isEmptyPackagesArray: false,
+    };
+}
+async function readWorkspaceYaml(rootDir, fs) {
+    const workspaceYamlPath = path.join(rootDir, PNPM_WORKSPACE);
+    if (!fs.existsSync(workspaceYamlPath)) {
+        return { exists: false };
+    }
+    let raw;
+    try {
+        raw = await fs.readFile(workspaceYamlPath, "utf8");
+    }
+    catch (caughtReadError) {
+        throw new Error(`Failed to read ${PNPM_WORKSPACE}: ${messageFromCaughtUnknown(caughtReadError)}`);
+    }
+    let doc;
+    try {
+        doc = parseYaml(raw);
+    }
+    catch (caughtYamlParseError) {
+        throw new Error(`Failed to parse ${PNPM_WORKSPACE}: ${messageFromCaughtUnknown(caughtYamlParseError)}`);
+    }
+    if (doc === null || doc === undefined) {
+        throw new Error(`${PNPM_WORKSPACE} must define a mapping at the document root`);
+    }
+    return { exists: true, doc };
+}
+/**
+ * Workspace package directories relative to `rootDir` (POSIX slashes), sorted.
+ * Reads `pnpm-workspace.yaml` when present; otherwise uses `packages/*`.
+ * Only paths with a `package.json` are returned (same practical rule as pnpm).
+ */
+export async function findWorkspacePackageRelPaths(rootDir, fs, logger) {
+    const workspaceYaml = await readWorkspaceYaml(rootDir, fs);
+    let include;
+    let exclude;
+    let multiSource;
+    if (!workspaceYaml.exists) {
+        include = [...DEFAULT_INCLUDE];
+        exclude = [];
+        multiSource = "default-patterns";
+    }
+    else {
+        const parsed = parsePnpmWorkspaceDocument(workspaceYaml.doc);
+        if (!parsed.hasPackagesKey) {
+            include = [...DEFAULT_INCLUDE];
+            exclude = [];
+            multiSource = "default-patterns";
+        }
+        else if (parsed.isEmptyPackagesArray) {
+            return { relPaths: [], multiSource: "declared-empty" };
+        }
+        else {
+            include = parsed.include;
+            exclude = parsed.exclude;
+            multiSource = "pnpm-workspace-yaml";
+        }
+    }
+    const found = new Set();
+    const globOpts = {
+        cwd: rootDir,
+        posix: true,
+        ...(path.sep === "\\" ? { windowsPathsNoEscape: true } : {}),
+    };
+    for (const pattern of include) {
+        const globPat = workspacePatternToPackageJsonGlob(pattern);
+        let matches;
+        try {
+            matches = globSync(globPat, globOpts);
+        }
+        catch (caughtGlobError) {
+            if (isGlobPermissionError(caughtGlobError)) {
+                mirrorGlobWarning(logger, `Skipping workspace glob "${pattern}" (${messageFromCaughtUnknown(caughtGlobError)})`);
+                continue;
+            }
+            throw new Error(`Invalid workspace glob "${pattern}": ${messageFromCaughtUnknown(caughtGlobError)}`);
+        }
+        for (const matchedPath of matches) {
+            const posix = toPosix(matchedPath);
+            if (!posix.endsWith("/package.json")) {
+                continue;
+            }
+            const rel = posix.slice(0, -"/package.json".length);
+            if (!rel) {
+                continue;
+            }
+            found.add(normalizePath(rel));
+        }
+    }
+    const excludeMatchers = exclude.map((pat) => picomatch(pat, { dot: true }));
+    const relPaths = [...found].filter((rel) => !excludeMatchers.some((isMatch) => isMatch(rel)));
+    relPaths.sort((a, b) => a.localeCompare(b));
+    return { relPaths, multiSource };
+}

package/dist/lib/mirror/infra/workspace-service.adapter.d.ts

@@ -0,0 +1,8 @@
+import type { CliFs, CliLogger } from "#lib/infra/fs-contract.port";
+import type { WorkspaceServicePort } from "#lib/mirror/application/ports/workspace-service.port";
+import type { FindWorkspacePackagesResult } from "#lib/mirror/domain/types.domain";
+export declare class WorkspaceServiceAdapter implements WorkspaceServicePort {
+    resolvePackageFilterUnderRoot(rootDir: string, packageFilter: string): string;
+    findWorkspacePackageRelPaths(rootDir: string, fs: CliFs, logger: CliLogger): Promise<FindWorkspacePackagesResult>;
+}
+//# sourceMappingURL=workspace-service.adapter.d.ts.map

package/dist/lib/mirror/infra/workspace-service.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace-service.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/mirror/infra/workspace-service.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sDAAsD,CAAC;AACjG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAInF,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,6BAA6B,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAE5E;IAED,4BAA4B,CAC1B,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,KAAK,EACT,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,2BAA2B,CAAC,CAEtC;CACF"}

package/dist/lib/mirror/infra/workspace-service.adapter.js

@@ -0,0 +1,10 @@
+import { resolvePackageFilterUnderRoot } from "#lib/mirror/infra/package-filter.adapter";
+import { findWorkspacePackageRelPaths } from "#lib/mirror/infra/workspace-packages.adapter";
+export class WorkspaceServiceAdapter {
+    resolvePackageFilterUnderRoot(rootDir, packageFilter) {
+        return resolvePackageFilterUnderRoot(rootDir, packageFilter);
+    }
+    findWorkspacePackageRelPaths(rootDir, fs, logger) {
+        return findWorkspacePackageRelPaths(rootDir, fs, logger);
+    }
+}

package/dist/lib/mirror/presentation/mirror-prelude.presenter.d.ts

@@ -0,0 +1,17 @@
+import type { CodefastConfig } from "#lib/config/domain/schema.domain";
+import type { AppError } from "#lib/core/domain/errors.domain";
+import { type Result } from "#lib/core/domain/result.model";
+import type { CliContainer } from "#lib/core/infra/container.adapter";
+import { type GlobalCliOptions } from "#lib/core/presentation/global-cli-options.presenter";
+export type MirrorSyncCommandPrelude = {
+    readonly globals: GlobalCliOptions;
+    readonly rootDir: string;
+    readonly config: CodefastConfig;
+    readonly packageFilter: string | undefined;
+};
+export declare function prepareMirrorSync(cli: CliContainer, args: {
+    readonly currentWorkingDirectory: string;
+    readonly packageArg: string | undefined;
+    readonly globalCliRaw: unknown;
+}): Promise<Result<MirrorSyncCommandPrelude, AppError>>;
+//# sourceMappingURL=mirror-prelude.presenter.d.ts.map

package/dist/lib/mirror/presentation/mirror-prelude.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mirror-prelude.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/mirror/presentation/mirror-prelude.presenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAM,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEtE,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,qDAAqD,CAAC;AAI7D,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5C,CAAC;AAEF,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE;IACJ,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC,GACA,OAAO,CAAC,MAAM,CAAC,wBAAwB,EAAE,QAAQ,CAAC,CAAC,CA6BrD"}

package/dist/lib/mirror/presentation/mirror-prelude.presenter.js

@@ -0,0 +1,35 @@
+import { ok } from "#lib/core/domain/result.model";
+import { tryLoadCodefastConfig } from "#lib/core/presentation/load-codefast-config.presenter";
+import { parseGlobalCliOptions, } from "#lib/core/presentation/global-cli-options.presenter";
+import { resolveCliWorkspaceRootStrict } from "#lib/core/presentation/workspace-root-strict.presenter";
+import { resolveMirrorPackageArgToRelative } from "#lib/mirror/presentation/resolve-mirror-package-arg.presenter";
+export async function prepareMirrorSync(cli, args) {
+    const globalsOutcome = parseGlobalCliOptions(args.globalCliRaw);
+    if (!globalsOutcome.ok) {
+        return globalsOutcome;
+    }
+    const rootOutcome = resolveCliWorkspaceRootStrict(cli);
+    if (!rootOutcome.ok) {
+        return rootOutcome;
+    }
+    const rootDir = rootOutcome.value;
+    const filterOutcome = resolveMirrorPackageArgToRelative({
+        fs: cli.fs,
+        rootDir,
+        packageArg: args.packageArg,
+        currentWorkingDirectory: args.currentWorkingDirectory,
+    });
+    if (!filterOutcome.ok) {
+        return filterOutcome;
+    }
+    const loadedOutcome = await tryLoadCodefastConfig(cli, rootDir);
+    if (!loadedOutcome.ok) {
+        return loadedOutcome;
+    }
+    return ok({
+        globals: globalsOutcome.value,
+        rootDir,
+        config: loadedOutcome.value.config,
+        packageFilter: filterOutcome.value,
+    });
+}

package/dist/lib/mirror/presentation/reporter.presenter.d.ts

@@ -0,0 +1,25 @@
+import type { CliLogger } from "#lib/core/application/ports/cli-io.port";
+import type { GlobalStats, PackageStats, WorkspaceMultiDiscoverySource } from "#lib/mirror/domain/types.domain";
+export declare function configureMirrorColors(noColor: boolean): void;
+export declare function printMirrorConfigWarnings(logger: CliLogger, warnings: string[]): void;
+export declare function mirrorGlobWarning(logger: CliLogger, message: string): void;
+export declare function logSkippedWorkspacePackage(logger: CliLogger, index: number, total: number, displayName: string, reason: string): void;
+export declare function mirrorBanner(logger: CliLogger): void;
+export type MirrorProcessingMode = {
+    kind: "single";
+} | {
+    kind: "multi";
+    source: WorkspaceMultiDiscoverySource;
+};
+export declare function mirrorProcessingMode(logger: CliLogger, mode: MirrorProcessingMode): void;
+export declare function mirrorNoPackages(logger: CliLogger): void;
+export declare function logPackageSuccess(logger: CliLogger, index: number, total: number, pkgStats: PackageStats, generatedDistAssetCounts: {
+    jsCount: number;
+    cssCount: number;
+}, verbose: boolean): void;
+export declare function logPrunedStaleExport(logger: CliLogger, exportSpecifier: string): void;
+export declare function logPackageError(logger: CliLogger, index: number, total: number, displayName: string, errValue: unknown, verbose: boolean): void;
+export declare function mirrorSummarySeparator(logger: CliLogger): void;
+export declare function mirrorSummary(logger: CliLogger, stats: GlobalStats, elapsedSeconds: number): void;
+export declare function mirrorFatalError(logger: CliLogger, caughtError: unknown): void;
+//# sourceMappingURL=reporter.presenter.d.ts.map

package/dist/lib/mirror/presentation/reporter.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/mirror/presentation/reporter.presenter.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,6BAA6B,EAC9B,MAAM,iCAAiC,CAAC;AAuBzC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAI5D;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAErF;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAG1E;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,IAAI,CAMN;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAIpD;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,6BAA6B,CAAA;CAAE,CAAC;AAE7D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAqBxF;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,YAAY,EACtB,wBAAwB,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC/D,OAAO,EAAE,OAAO,GACf,IAAI,CA0CN;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,IAAI,CAIrF;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,OAAO,GACf,IAAI,CAeN;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAE9D;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAkCjG;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,GAAG,IAAI,CAQ9E"}

package/dist/lib/mirror/presentation/reporter.presenter.js

@@ -0,0 +1,140 @@
+import process from "node:process";
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+import { printConfigSchemaWarnings } from "#lib/infra/config-reporter.adapter";
+const Colors = {
+    RESET: "\x1b[0m",
+    BOLD: "\x1b[1m",
+    DIM: "\x1b[2m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+    CYAN: "\x1b[36m",
+    GRAY: "\x1b[90m",
+    MAGENTA: "\x1b[35m",
+    BRIGHT_GREEN: "\x1b[92m",
+    BRIGHT_YELLOW: "\x1b[93m",
+    BRIGHT_CYAN: "\x1b[96m",
+    disable() {
+        for (const key of Object.keys(this)) {
+            if (typeof this[key] === "string") {
+                this[key] = "";
+            }
+        }
+    },
+};
+export function configureMirrorColors(noColor) {
+    if (!process.stdout.isTTY || noColor) {
+        Colors.disable();
+    }
+}
+export function printMirrorConfigWarnings(logger, warnings) {
+    printConfigSchemaWarnings(logger, warnings);
+}
+export function mirrorGlobWarning(logger, message) {
+    const { out } = logger;
+    out(`${Colors.YELLOW}⚠ ${message}${Colors.RESET}`);
+}
+export function logSkippedWorkspacePackage(logger, index, total, displayName, reason) {
+    const { out } = logger;
+    const progress = `${Colors.DIM}[${index}/${total}]${Colors.RESET}`;
+    out(`${progress} ${Colors.GRAY}○${Colors.RESET} ${Colors.DIM}${displayName}${Colors.RESET}`);
+    out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.GRAY}Skipped: ${reason}${Colors.RESET}`);
+    out("");
+}
+export function mirrorBanner(logger) {
+    const { out } = logger;
+    out(`\n${Colors.BOLD}${Colors.CYAN}📦 Mirror — package exports${Colors.RESET}`);
+    out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}\n`);
+}
+export function mirrorProcessingMode(logger, mode) {
+    const { out } = logger;
+    if (mode.kind === "single") {
+        out(`${Colors.DIM}Processing single package...${Colors.RESET}\n`);
+        return;
+    }
+    switch (mode.source) {
+        case "default-patterns":
+            out(`${Colors.DIM}Discovering workspace packages using default patterns (packages/*)…${Colors.RESET}\n`);
+            break;
+        case "pnpm-workspace-yaml":
+            out(`${Colors.DIM}Discovering workspace packages from pnpm-workspace.yaml…${Colors.RESET}\n`);
+            break;
+        case "declared-empty":
+            out(`${Colors.DIM}pnpm-workspace.yaml declares an empty workspace package list.${Colors.RESET}\n`);
+            break;
+    }
+}
+export function mirrorNoPackages(logger) {
+    logger.out(`${Colors.YELLOW}⚠ No packages found${Colors.RESET}`);
+}
+export function logPackageSuccess(logger, index, total, pkgStats, generatedDistAssetCounts, verbose) {
+    const { out } = logger;
+    const progress = `${Colors.DIM}[${index}/${total}]${Colors.RESET}`;
+    out(`${progress} ${Colors.BRIGHT_GREEN}✓${Colors.RESET} ${Colors.BOLD}${pkgStats.name}${Colors.RESET}`);
+    if (verbose) {
+        out(`  ${Colors.DIM}├─${Colors.RESET} Path: ${pkgStats.path}`);
+        if (pkgStats.hasTransform) {
+            out(`  ${Colors.DIM}├─${Colors.RESET} ${Colors.CYAN}Custom path transformation${Colors.RESET}`);
+        }
+        if (pkgStats.cssConfigStatus) {
+            out(`  ${Colors.DIM}├─${Colors.RESET} ${Colors.CYAN}${pkgStats.cssConfigStatus === "disabled" ? "CSS disabled" : "CSS configured"}${Colors.RESET}`);
+        }
+    }
+    const breakdown = [];
+    if (generatedDistAssetCounts.jsCount > 0) {
+        breakdown.push(`${Colors.GREEN}${generatedDistAssetCounts.jsCount} modules${Colors.RESET}`);
+    }
+    if (generatedDistAssetCounts.cssCount > 0) {
+        breakdown.push(`${Colors.MAGENTA}${generatedDistAssetCounts.cssCount} CSS${Colors.RESET}`);
+    }
+    if (pkgStats.customExports > 0) {
+        breakdown.push(`${Colors.YELLOW}${pkgStats.customExports} custom${Colors.RESET}`);
+    }
+    if (breakdown.length > 0) {
+        out(`  ${Colors.DIM}└─${Colors.RESET} ${breakdown.join(" + ")} = ${Colors.BRIGHT_CYAN}${pkgStats.totalExports} exports${Colors.RESET}`);
+    }
+    else {
+        out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.BRIGHT_CYAN}${pkgStats.totalExports} exports${Colors.RESET}`);
+    }
+    out("");
+}
+export function logPrunedStaleExport(logger, exportSpecifier) {
+    logger.out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.GRAY}Pruned stale export: ${exportSpecifier}${Colors.RESET}`);
+}
+export function logPackageError(logger, index, total, displayName, errValue, verbose) {
+    const { out, err: errLine } = logger;
+    out(`${Colors.DIM}[${index}/${total}]${Colors.RESET} ${Colors.YELLOW}✗${Colors.RESET} ${Colors.BOLD}${displayName}${Colors.RESET}`);
+    out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.YELLOW}Error: ${messageFromCaughtUnknown(errValue)}${Colors.RESET}\n`);
+    if (verbose) {
+        errLine(errValue instanceof Error && errValue.stack
+            ? errValue.stack
+            : messageFromCaughtUnknown(errValue));
+    }
+}
+export function mirrorSummarySeparator(logger) {
+    logger.out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}`);
+}
+export function mirrorSummary(logger, stats, elapsedSeconds) {
+    const { out } = logger;
+    out(`${Colors.BOLD}📊 Summary${Colors.RESET} ${Colors.DIM}(completed in ${elapsedSeconds.toFixed(2)}s)${Colors.RESET}\n`);
+    out(`  ${Colors.BOLD}Packages:${Colors.RESET}`);
+    out(`  ${Colors.DIM}├─${Colors.RESET} Processed: ${Colors.GREEN}${stats.packagesProcessed}${Colors.RESET}`);
+    if (stats.packagesSkipped > 0) {
+        out(`  ${Colors.DIM}├─${Colors.RESET} Skipped: ${Colors.GRAY}${stats.packagesSkipped}${Colors.RESET}`);
+    }
+    if (stats.packagesErrored > 0) {
+        out(`  ${Colors.DIM}├─${Colors.RESET} Errors: ${Colors.YELLOW}${stats.packagesErrored}${Colors.RESET}`);
+    }
+    out(`  ${Colors.DIM}└─${Colors.RESET} Total found: ${stats.packagesFound}\n`);
+    out(`  ${Colors.BOLD}Exports:${Colors.RESET}`);
+    out(`  ${Colors.DIM}├─${Colors.RESET} JS Modules: ${Colors.CYAN}${stats.totalJsModules}${Colors.RESET}`);
+    out(`  ${Colors.DIM}├─${Colors.RESET} CSS Files: ${Colors.MAGENTA}${stats.totalCssExports}${Colors.RESET}`);
+    out(`  ${Colors.DIM}└─${Colors.RESET} Total: ${Colors.BRIGHT_CYAN}${stats.totalExports}${Colors.RESET}\n`);
+    out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}\n`);
+}
+export function mirrorFatalError(logger, caughtError) {
+    const { out, err: errLine } = logger;
+    out(`${Colors.YELLOW}Fatal error: ${messageFromCaughtUnknown(caughtError)}${Colors.RESET}`);
+    errLine(caughtError instanceof Error && caughtError.stack
+        ? caughtError.stack
+        : messageFromCaughtUnknown(caughtError));
+}

package/dist/lib/mirror/presentation/resolve-mirror-package-arg.presenter.d.ts

@@ -0,0 +1,11 @@
+import type { CliFs } from "#lib/core/application/ports/cli-io.port";
+import { type AppError } from "#lib/core/domain/errors.domain";
+import { type Result } from "#lib/core/domain/result.model";
+export type ResolveMirrorPackageArgInput = {
+    readonly fs: CliFs;
+    readonly rootDir: string;
+    readonly packageArg: string | undefined;
+    readonly currentWorkingDirectory: string;
+};
+export declare function resolveMirrorPackageArgToRelative(input: ResolveMirrorPackageArgInput): Result<string | undefined, AppError>;
+//# sourceMappingURL=resolve-mirror-package-arg.presenter.d.ts.map

package/dist/lib/mirror/presentation/resolve-mirror-package-arg.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-mirror-package-arg.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/mirror/presentation/resolve-mirror-package-arg.presenter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AACrE,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAErE,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;CAC1C,CAAC;AAMF,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,4BAA4B,GAClC,MAAM,CAAC,MAAM,GAAG,SAAS,EAAE,QAAQ,CAAC,CA2BtC"}

package/dist/lib/mirror/presentation/resolve-mirror-package-arg.presenter.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import { appError } from "#lib/core/domain/errors.domain";
+import { err, ok } from "#lib/core/domain/result.model";
+function normalizePathSegments(relPath) {
+    return relPath.split(path.sep).join("/").replace(/\\/g, "/");
+}
+export function resolveMirrorPackageArgToRelative(input) {
+    const { fs, rootDir, packageArg, currentWorkingDirectory } = input;
+    if (!packageArg) {
+        return ok(undefined);
+    }
+    const rootReal = fs.canonicalPathSync(path.resolve(rootDir));
+    const cwdReal = fs.canonicalPathSync(currentWorkingDirectory);
+    const resolved = path.isAbsolute(packageArg)
+        ? path.resolve(packageArg)
+        : path.resolve(cwdReal, packageArg);
+    const targetReal = fs.canonicalPathSync(resolved);
+    const rel = path.relative(rootReal, targetReal);
+    const normalized = normalizePathSegments(rel);
+    if (normalized.startsWith("..") ||
+        path.isAbsolute(normalized) ||
+        normalized === "" ||
+        normalized === ".") {
+        return err(appError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
+    }
+    return ok(normalized);
+}