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

package/dist/lib/tag/infra/tag-sync-cli-options.adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/infra/tag-target-candidates.adapter.d.ts

@@ -0,0 +1,4 @@
+import type { CliFs } from "#lib/infra/fs-contract.port";
+import type { TagTargetCandidate } from "#lib/tag/domain/types.domain";
+export declare function resolveTagTargetCandidates(rootDir: string, explicitTarget: string | undefined, fs: CliFs): Promise<TagTargetCandidate[]>;
+//# sourceMappingURL=tag-target-candidates.adapter.d.ts.map

package/dist/lib/tag/infra/tag-target-candidates.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-target-candidates.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/infra/tag-target-candidates.adapter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AA2MvE,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,EAAE,EAAE,KAAK,GACR,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAkC/B"}

package/dist/lib/tag/infra/tag-target-candidates.adapter.js

@@ -0,0 +1,200 @@
+import { globSync } from "node:fs";
+import path from "node:path";
+import picomatch from "picomatch";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+const PACKAGE_JSON_FILE = "package.json";
+const DEFAULT_WORKSPACE_PACKAGE_PATTERNS = ["packages/*"];
+const PnpmWorkspaceSchema = z
+    .object({
+    packages: z.array(z.string()).optional(),
+})
+    .passthrough();
+const PackageNameSchema = z
+    .object({
+    name: z.string().min(1).optional(),
+})
+    .passthrough();
+function toPosix(filePath) {
+    return filePath.split(path.sep).join("/");
+}
+function workspacePatternToPackageJsonGlob(pattern) {
+    const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
+    if (!normalizedPattern) {
+        return `**/${PACKAGE_JSON_FILE}`;
+    }
+    return `${normalizedPattern}/${PACKAGE_JSON_FILE}`;
+}
+function splitWorkspacePackagePatterns(rawPatterns) {
+    const include = [];
+    const exclude = [];
+    for (const rawPattern of rawPatterns) {
+        const trimmedPattern = rawPattern.trim();
+        if (!trimmedPattern) {
+            continue;
+        }
+        if (trimmedPattern.startsWith("!")) {
+            exclude.push(trimmedPattern.slice(1).trim());
+            continue;
+        }
+        include.push(trimmedPattern);
+    }
+    return { include, exclude };
+}
+async function readWorkspacePackagePatterns(rootDir, fs) {
+    const workspaceYamlPath = path.join(rootDir, PNPM_WORKSPACE_FILE);
+    if (!fs.existsSync(workspaceYamlPath)) {
+        return {
+            patterns: [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS],
+            hasWorkspaceFile: false,
+            declaredEmptyPackages: false,
+        };
+    }
+    let workspaceYamlRaw = "";
+    try {
+        workspaceYamlRaw = await fs.readFile(workspaceYamlPath, "utf8");
+    }
+    catch (caughtReadError) {
+        throw new Error(`Failed to read ${PNPM_WORKSPACE_FILE}: ${messageFromCaughtUnknown(caughtReadError)}`);
+    }
+    let parsedWorkspaceDoc;
+    try {
+        parsedWorkspaceDoc = parseYaml(workspaceYamlRaw);
+    }
+    catch (caughtParseError) {
+        throw new Error(`Failed to parse ${PNPM_WORKSPACE_FILE}: ${messageFromCaughtUnknown(caughtParseError)}`);
+    }
+    const parsedWorkspaceResult = PnpmWorkspaceSchema.safeParse(parsedWorkspaceDoc);
+    if (!parsedWorkspaceResult.success) {
+        const issuePath = parsedWorkspaceResult.error.issues[0]?.path.join(".") ?? "<root>";
+        const issueMessage = parsedWorkspaceResult.error.issues[0]?.message ?? "Invalid value";
+        throw new Error(`Invalid ${PNPM_WORKSPACE_FILE} schema at "${issuePath}": ${issueMessage}`);
+    }
+    const hasPackagesKey = typeof parsedWorkspaceDoc === "object" &&
+        parsedWorkspaceDoc !== null &&
+        Object.prototype.hasOwnProperty.call(parsedWorkspaceDoc, "packages");
+    const workspacePackages = parsedWorkspaceResult.data.packages;
+    if (!workspacePackages) {
+        return {
+            patterns: [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS],
+            hasWorkspaceFile: true,
+            declaredEmptyPackages: false,
+        };
+    }
+    if (workspacePackages.length === 0 && hasPackagesKey) {
+        return { patterns: [], hasWorkspaceFile: true, declaredEmptyPackages: true };
+    }
+    return {
+        patterns: workspacePackages,
+        hasWorkspaceFile: true,
+        declaredEmptyPackages: false,
+    };
+}
+async function discoverWorkspacePackageDirs(rootDir, fs) {
+    const workspacePackages = await readWorkspacePackagePatterns(rootDir, fs);
+    const { include, exclude } = splitWorkspacePackagePatterns(workspacePackages.patterns);
+    const includePatterns = include.length > 0 ? include : [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS];
+    const foundPackageDirs = new Set();
+    const globOptions = {
+        cwd: rootDir,
+        posix: true,
+        ...(path.sep === "\\" ? { windowsPathsNoEscape: true } : {}),
+    };
+    for (const pattern of includePatterns) {
+        const packageJsonGlob = workspacePatternToPackageJsonGlob(pattern);
+        const matches = globSync(packageJsonGlob, globOptions);
+        for (const matchedPath of matches) {
+            if (!matchedPath.endsWith(`/${PACKAGE_JSON_FILE}`)) {
+                continue;
+            }
+            const packageRelDir = matchedPath.slice(0, -`/${PACKAGE_JSON_FILE}`.length);
+            if (!packageRelDir) {
+                continue;
+            }
+            foundPackageDirs.add(path.resolve(rootDir, packageRelDir));
+        }
+    }
+    if (exclude.length === 0) {
+        return {
+            packageDirs: [...foundPackageDirs].sort((leftDir, rightDir) => leftDir.localeCompare(rightDir)),
+            hasWorkspaceFile: workspacePackages.hasWorkspaceFile,
+            declaredEmptyPackages: workspacePackages.declaredEmptyPackages,
+        };
+    }
+    const excludeMatchers = exclude.map((excludePattern) => picomatch(excludePattern, { dot: true }));
+    const discoveredDirs = [...foundPackageDirs].filter((packageDir) => {
+        const relativePackagePath = toPosix(path.relative(rootDir, packageDir));
+        return !excludeMatchers.some((excludeMatcher) => excludeMatcher(relativePackagePath));
+    });
+    discoveredDirs.sort((leftDir, rightDir) => leftDir.localeCompare(rightDir));
+    return {
+        packageDirs: discoveredDirs,
+        hasWorkspaceFile: workspacePackages.hasWorkspaceFile,
+        declaredEmptyPackages: workspacePackages.declaredEmptyPackages,
+    };
+}
+function readPackageName(packageDir, fs) {
+    const packageJsonPath = path.join(packageDir, PACKAGE_JSON_FILE);
+    if (!fs.existsSync(packageJsonPath)) {
+        return null;
+    }
+    try {
+        const rawPackageJson = fs.readFileSync(packageJsonPath, "utf8");
+        const parsedPackageJson = JSON.parse(rawPackageJson);
+        const parsedPackageName = PackageNameSchema.safeParse(parsedPackageJson);
+        if (!parsedPackageName.success) {
+            return null;
+        }
+        return parsedPackageName.data.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function toRootRelativePath(rootDir, absolutePath) {
+    const relativePath = path.relative(rootDir, absolutePath);
+    return relativePath ? toPosix(relativePath) : ".";
+}
+function toPackageTargetCandidate(rootDir, packageDir, fs) {
+    const packageName = readPackageName(packageDir, fs);
+    return {
+        candidatePath: packageDir,
+        rootRelativeCandidatePath: toRootRelativePath(rootDir, packageDir),
+        source: "workspace-package",
+        packageDir,
+        packageName,
+    };
+}
+export async function resolveTagTargetCandidates(rootDir, explicitTarget, fs) {
+    if (explicitTarget) {
+        const resolvedExplicitTarget = path.resolve(explicitTarget);
+        return [
+            {
+                candidatePath: resolvedExplicitTarget,
+                rootRelativeCandidatePath: toRootRelativePath(rootDir, resolvedExplicitTarget),
+                source: "explicit-target",
+                packageDir: null,
+                packageName: null,
+            },
+        ];
+    }
+    const workspaceDiscovery = await discoverWorkspacePackageDirs(rootDir, fs);
+    if (workspaceDiscovery.packageDirs.length === 0) {
+        if (workspaceDiscovery.hasWorkspaceFile) {
+            return [];
+        }
+        const repoSourceDir = path.join(rootDir, "src");
+        return [
+            {
+                candidatePath: repoSourceDir,
+                rootRelativeCandidatePath: toRootRelativePath(rootDir, repoSourceDir),
+                source: "repo-src-fallback",
+                packageDir: null,
+                packageName: null,
+            },
+        ];
+    }
+    return workspaceDiscovery.packageDirs.map((packageDir) => toPackageTargetCandidate(rootDir, packageDir, fs));
+}

package/dist/lib/tag/infra/tag-target-resolver.adapter.d.ts

@@ -0,0 +1,3 @@
+import type { TagTargetResolverPort } from "#lib/tag/application/ports/target-resolver.port";
+export declare const tagTargetResolverAdapter: TagTargetResolverPort;
+//# sourceMappingURL=tag-target-resolver.adapter.d.ts.map

package/dist/lib/tag/infra/tag-target-resolver.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-target-resolver.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/infra/tag-target-resolver.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAG7F,eAAO,MAAM,wBAAwB,EAAE,qBAEtC,CAAC"}

package/dist/lib/tag/infra/tag-target-resolver.adapter.js

@@ -0,0 +1,4 @@
+import { resolveTagTargetCandidates } from "#lib/tag/infra/tag-target-candidates.adapter";
+export const tagTargetResolverAdapter = {
+    resolveTagTargetCandidates,
+};

package/dist/lib/tag/infra/typescript-tree-walk.adapter.d.ts

@@ -0,0 +1,3 @@
+import type { TypeScriptTreeWalkPort } from "#lib/tag/application/ports/typescript-tree-walk.port";
+export declare const tagTypeScriptTreeWalkAdapter: TypeScriptTreeWalkPort;
+//# sourceMappingURL=typescript-tree-walk.adapter.d.ts.map

package/dist/lib/tag/infra/typescript-tree-walk.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-tree-walk.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/infra/typescript-tree-walk.adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAEnG,eAAO,MAAM,4BAA4B,EAAE,sBAE1C,CAAC"}

package/dist/lib/tag/infra/typescript-tree-walk.adapter.js

@@ -0,0 +1,4 @@
+import { walkTsxFiles } from "#lib/shared/source-code/infra/tsx-file-walk.adapter";
+export const tagTypeScriptTreeWalkAdapter = {
+    walkTsxFiles,
+};

package/dist/lib/tag/presentation/colors.presenter.d.ts

@@ -0,0 +1,8 @@
+export declare const TAG_COLORS: {
+    readonly RESET: "\u001B[0m";
+    readonly RED: "\u001B[31m";
+    readonly GREEN: "\u001B[32m";
+    readonly YELLOW: "\u001B[33m";
+};
+export declare function withTagColor(line: string, colorCode: string): string;
+//# sourceMappingURL=colors.presenter.d.ts.map

package/dist/lib/tag/presentation/colors.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/colors.presenter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;aACrB,KAAK,EAAE,WAAS;aAChB,GAAG,EAAE,YAAU;aACf,KAAK,EAAE,YAAU;aACjB,MAAM,EAAE,YAAU;CACV,CAAC;AAEX,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpE"}

package/dist/lib/tag/presentation/colors.presenter.js

@@ -0,0 +1,9 @@
+export const TAG_COLORS = {
+    RESET: "\x1b[0m",
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+};
+export function withTagColor(line, colorCode) {
+    return `${colorCode}${line}${TAG_COLORS.RESET}`;
+}

package/dist/lib/tag/presentation/resolve-tag-cli-target.presenter.d.ts

@@ -0,0 +1,8 @@
+import type { CliFs } from "#lib/core/application/ports/cli-io.port";
+export type ResolveTagCliTargetPathInput = {
+    readonly fs: CliFs;
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+};
+export declare function resolveTagCliTargetPath(input: ResolveTagCliTargetPathInput): string | undefined;
+//# sourceMappingURL=resolve-tag-cli-target.presenter.d.ts.map

package/dist/lib/tag/presentation/resolve-tag-cli-target.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-tag-cli-target.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/resolve-tag-cli-target.presenter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AAErE,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,4BAA4B,GAAG,MAAM,GAAG,SAAS,CAQ/F"}

package/dist/lib/tag/presentation/resolve-tag-cli-target.presenter.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+export function resolveTagCliTargetPath(input) {
+    if (input.rawTarget === undefined) {
+        return undefined;
+    }
+    const candidate = path.isAbsolute(input.rawTarget)
+        ? path.resolve(input.rawTarget)
+        : path.resolve(input.currentWorkingDirectory, input.rawTarget);
+    return input.fs.canonicalPathSync(candidate);
+}

package/dist/lib/tag/presentation/resolve-tag-workspace-root.presenter.d.ts

@@ -0,0 +1,8 @@
+import type { CliLogger } from "#lib/core/application/ports/cli-io.port";
+export type ResolveTagWorkspaceRootPathInput = {
+    readonly resolveStrictRepoRoot: () => string;
+    readonly logger: CliLogger;
+    readonly currentWorkingDirectory: string;
+};
+export declare function resolveTagWorkspaceRootPath(input: ResolveTagWorkspaceRootPathInput): string;
+//# sourceMappingURL=resolve-tag-workspace-root.presenter.d.ts.map

package/dist/lib/tag/presentation/resolve-tag-workspace-root.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-tag-workspace-root.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/resolve-tag-workspace-root.presenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGzE,MAAM,MAAM,gCAAgC,GAAG;IAC7C,QAAQ,CAAC,qBAAqB,EAAE,MAAM,MAAM,CAAC;IAC7C,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;CAC1C,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,gCAAgC,GAAG,MAAM,CAS3F"}

package/dist/lib/tag/presentation/resolve-tag-workspace-root.presenter.js

@@ -0,0 +1,10 @@
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+export function resolveTagWorkspaceRootPath(input) {
+    try {
+        return input.resolveStrictRepoRoot();
+    }
+    catch (caughtRepoRootError) {
+        input.logger.out(`[tag] workspace root auto-detection failed (${messageFromCaughtUnknown(caughtRepoRootError)}), using cwd=${input.currentWorkingDirectory}`);
+        return input.currentWorkingDirectory;
+    }
+}

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

@@ -0,0 +1,15 @@
+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";
+export type TagCommandPrelude = {
+    readonly rootDir: string;
+    readonly config: CodefastConfig;
+    readonly resolvedTargetPath: string | undefined;
+};
+export declare function prepareTagSync(cli: CliContainer, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+    readonly globalCliRaw: unknown;
+}): Promise<Result<TagCommandPrelude, AppError>>;
+//# sourceMappingURL=tag-prelude.presenter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag-prelude.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/tag-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;AAOtE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAC;CACjD,CAAC;AAEF,wBAAsB,cAAc,CAClC,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE;IACJ,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC,GACA,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC,CAwB9C"}

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

@@ -0,0 +1,31 @@
+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 { findRepoRoot } from "#lib/infra/workspace/repo-root.adapter";
+import { resolveTagCliTargetPath } from "#lib/tag/presentation/resolve-tag-cli-target.presenter";
+import { resolveTagWorkspaceRootPath } from "#lib/tag/presentation/resolve-tag-workspace-root.presenter";
+export async function prepareTagSync(cli, args) {
+    const globalsOutcome = parseGlobalCliOptions(args.globalCliRaw);
+    if (!globalsOutcome.ok) {
+        return globalsOutcome;
+    }
+    const rootDir = resolveTagWorkspaceRootPath({
+        resolveStrictRepoRoot: () => findRepoRoot(cli.fs),
+        logger: cli.logger,
+        currentWorkingDirectory: args.currentWorkingDirectory,
+    });
+    const loadedOutcome = await tryLoadCodefastConfig(cli, rootDir);
+    if (!loadedOutcome.ok) {
+        return loadedOutcome;
+    }
+    const resolvedTargetPath = resolveTagCliTargetPath({
+        fs: cli.fs,
+        currentWorkingDirectory: args.currentWorkingDirectory,
+        rawTarget: args.rawTarget,
+    });
+    return ok({
+        rootDir,
+        config: loadedOutcome.value.config,
+        resolvedTargetPath,
+    });
+}

package/dist/lib/tag/presentation/tag-sync.presenter.d.ts

@@ -0,0 +1,20 @@
+import type { CliLogger } from "#lib/core/application/ports/cli-io.port";
+import type { TagProgressListener, TagResolvedTarget, TagSyncResult, TagTargetExecutionResult } from "#lib/tag/domain/types.domain";
+export type TagProgressEvent = {
+    type: "target-started";
+    target: TagResolvedTarget;
+} | {
+    type: "target-completed";
+    target: TagResolvedTarget;
+    result: TagTargetExecutionResult;
+};
+export declare function formatProgress(event: TagProgressEvent): string;
+export declare function formatTargetTable(targets: TagResolvedTarget[], rootDir: string): string;
+export declare function formatWarningsAndErrors(result: TagSyncResult): string | null;
+export declare function formatSummary(result: TagSyncResult): string;
+/**
+ * Prints tag sync output and returns a process exit code (0 success, 1 when empty targets or hook/run errors).
+ */
+export declare function presentTagSyncCliResult(logger: CliLogger, tagResult: TagSyncResult, rootDir: string): number;
+export declare function createTagProgressListener(onProgressLine: (line: string) => void): TagProgressListener;
+//# sourceMappingURL=tag-sync.presenter.d.ts.map

package/dist/lib/tag/presentation/tag-sync.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-sync.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/tag-sync.presenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,MAAM,EAAE,wBAAwB,CAAA;CAAE,CAAC;AAmB9F,wBAAgB,cAAc,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAM9D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAyBvF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAU5E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAqB3D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,CAiBR;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GACrC,mBAAmB,CASrB"}

package/dist/lib/tag/presentation/tag-sync.presenter.js

@@ -0,0 +1,92 @@
+import { TAG_COLORS, withTagColor } from "#lib/tag/presentation/colors.presenter";
+function targetDisplayName(target) {
+    return target.packageName ?? target.rootRelativeTargetPath;
+}
+function warningsAndErrorsFromResult(result) {
+    const entries = [];
+    for (const targetResult of result.targetResults) {
+        if (targetResult.runError) {
+            entries.push(targetResult.runError);
+        }
+    }
+    if (result.hookError) {
+        entries.push(result.hookError);
+    }
+    return entries;
+}
+export function formatProgress(event) {
+    if (event.type === "target-started") {
+        return `[tag] Processing ${targetDisplayName(event.target)}...`;
+    }
+    const changedFiles = event.result.result?.filesChanged ?? 0;
+    return `[tag] Done ${targetDisplayName(event.target)} (${changedFiles} changes)`;
+}
+export function formatTargetTable(targets, rootDir) {
+    const packageColumnWidth = Math.max("package".length, ...targets.map((target) => (target.packageName ?? "-").length));
+    const pathColumnWidth = Math.max("path".length, ...targets.map((target) => target.rootRelativeTargetPath.length));
+    const lines = [];
+    lines.push(`[tag] Root: ${rootDir}`);
+    lines.push(`[tag] Resolved targets: ${targets.length}`);
+    lines.push("[tag] Targets:");
+    lines.push(`  ${"package".padEnd(packageColumnWidth)}   ${"path".padEnd(pathColumnWidth)}   source`);
+    lines.push(`  ${"-".repeat(packageColumnWidth)}   ${"-".repeat(pathColumnWidth)}   ${"-".repeat("source".length)}`);
+    for (const target of targets) {
+        lines.push(`  ${(target.packageName ?? "-").padEnd(packageColumnWidth)}   ${target.rootRelativeTargetPath.padEnd(pathColumnWidth)}   ${target.source}`);
+    }
+    return lines.join("\n");
+}
+export function formatWarningsAndErrors(result) {
+    const entries = warningsAndErrorsFromResult(result);
+    if (entries.length === 0) {
+        return null;
+    }
+    const lines = [withTagColor("⚠️ Warnings & Errors", TAG_COLORS.YELLOW)];
+    for (const entry of entries) {
+        lines.push(withTagColor(`- ${entry}`, TAG_COLORS.RED));
+    }
+    return lines.join("\n");
+}
+export function formatSummary(result) {
+    const isDryRun = result.mode === "dry-run";
+    const summaryPrefix = isDryRun ? "[tag:dry-run]" : "[tag]";
+    const versionSuffix = result.versionSummary === "mixed" && result.distinctVersions.length > 0
+        ? ` [${result.distinctVersions.join(", ")}]`
+        : "";
+    const hasError = result.targetResults.some((targetResult) => targetResult.runError !== null) ||
+        result.hookError !== null;
+    const summaryColor = hasError ? TAG_COLORS.RED : isDryRun ? TAG_COLORS.YELLOW : TAG_COLORS.GREEN;
+    const lines = [
+        withTagColor(`${summaryPrefix} version=${result.versionSummary}${versionSuffix} files=${result.filesChanged}/${result.filesScanned} declarations=${result.taggedDeclarations}`, summaryColor),
+    ];
+    if (result.skippedPackages.length > 0) {
+        lines.push(`[tag] Skipped: ${result.skippedPackages.length} package(s)`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Prints tag sync output and returns a process exit code (0 success, 1 when empty targets or hook/run errors).
+ */
+export function presentTagSyncCliResult(logger, tagResult, rootDir) {
+    logger.out(formatTargetTable(tagResult.selectedTargets, rootDir));
+    if (tagResult.selectedTargets.length === 0) {
+        logger.err("No packages found in workspace. Check your pnpm-workspace.yaml or provide an explicit target path.");
+        return 1;
+    }
+    const warningsAndErrorsSection = formatWarningsAndErrors(tagResult);
+    if (warningsAndErrorsSection) {
+        logger.err(warningsAndErrorsSection);
+    }
+    logger.out(formatSummary(tagResult));
+    const hasRunErrors = tagResult.targetResults.some((targetResult) => targetResult.runError !== null);
+    return hasRunErrors || tagResult.hookError ? 1 : 0;
+}
+export function createTagProgressListener(onProgressLine) {
+    return {
+        onTargetStarted: (target) => {
+            onProgressLine(formatProgress({ type: "target-started", target }));
+        },
+        onTargetCompleted: (target, result) => {
+            onProgressLine(formatProgress({ type: "target-completed", target, result }));
+        },
+    };
+}

package/dist/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function createProgram(): Command;
+export declare function runCli(argv: string[]): Promise<number>;
+//# sourceMappingURL=program.d.ts.map

package/dist/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,wBAAgB,aAAa,IAAI,OAAO,CAevC;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAK5D"}

package/dist/program.js

@@ -0,0 +1,40 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { registerArrangeCommand } from "#commands/arrange";
+import { registerMirrorCommand } from "#commands/mirror";
+import { registerTagCommand } from "#commands/tag";
+function readVersion() {
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(dir, "..", "package.json");
+        const raw = readFileSync(pkgPath, "utf-8");
+        const pkgVersion = JSON.parse(raw).version;
+        return typeof pkgVersion === "string" && pkgVersion.length > 0 ? pkgVersion : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("codefast")
+        .description("Codefast monorepo developer CLI")
+        .version(readVersion())
+        .option("--no-color", "Disable ANSI color output")
+        .configureHelp({ sortSubcommands: true })
+        .showHelpAfterError("(use --help for usage)");
+    registerMirrorCommand(program);
+    registerArrangeCommand(program);
+    registerTagCommand(program);
+    return program;
+}
+export async function runCli(argv) {
+    const program = createProgram();
+    await program.parseAsync(argv, { from: "node" });
+    const code = process.exitCode ?? 0;
+    return typeof code === "number" ? code : Number(code) || 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.3.13-canary.1",
+  "version": "0.3.13-canary.3",
   "description": "Developer CLI for the Codefast monorepo (mirror, arrange)",
   "keywords": [
     "cli",
@@ -22,7 +22,7 @@
     "directory": "packages/cli"
   },
   "bin": {
-    "codefast": "./dist/bin.mjs"
+    "codefast": "./dist/bin.js"
   },
   "files": [
     "dist",
@@ -33,6 +33,9 @@
   "type": "module",
   "imports": {
     "#*": [
+      "./dist/*.js",
+      "./dist/*/index.js",
+      "./dist/*",
       "./src/*",
       "./src/*.ts",
       "./src/*.tsx",
@@ -59,17 +62,17 @@
     "@types/picomatch": "^4.0.3",
     "@typescript/native-preview": "7.0.0-dev.20260411.1",
     "jest": "^30.3.0",
-    "tsdown": "^0.21.8",
-    "@codefast/typescript-config": "0.3.13-canary.1"
+    "@codefast/typescript-config": "0.3.13-canary.3"
   },
   "engines": {
     "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "rm -rf dist && tsgo -p tsconfig.build.json",
     "check-types": "tsgo --noEmit",
     "clean": "rm -rf dist",
     "test": "jest",
+    "check-architecture": "jest src/__tests__/architecture.test.ts",
     "test:coverage": "jest --coverage",
     "test:coverage:ci": "jest --coverage --ci",
     "test:watch": "jest --watch"