@codefast/cli 0.5.0-canary.4 → 0.5.0-canary.6

package/dist/tag/sync.mjs

@@ -1,149 +0,0 @@
-import { AppError, messageFrom } from "../core/errors.mjs";
-import { err, ok } from "../core/result.mjs";
-import { createAnyGlobMatcher } from "../core/glob.mjs";
-import { resolveTagTargetCandidates } from "./target-candidates.mjs";
-import { runTagOnTarget } from "./target-runner.mjs";
-import path from "node:path";
-//#region src/tag/sync.ts
-/**
-* @since 0.3.16-canary.0
-*/
-async function runTagSync(fs, input) {
-	try {
-		const tagConfig = input.config;
-		const { includedCandidates, skippedPackages } = filterSkippedCandidates(await resolveTagTargetCandidates(fs, input.rootDir, input.targetPath), input.skipPackages);
-		const selectedTargets = includedCandidates.map((candidate) => resolveTargetSelection(fs, candidate, input.rootDir));
-		const targetExecutionResults = await Promise.all(selectedTargets.map((resolvedTarget) => runOnResolvedTarget(fs, resolvedTarget, input.write, input.listener)));
-		const allFileResults = targetExecutionResults.flatMap((targetResult) => targetResult.result?.fileResults ?? []);
-		const filesScanned = targetExecutionResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesScanned ?? 0), 0);
-		const filesChanged = targetExecutionResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesChanged ?? 0), 0);
-		const taggedDeclarations = targetExecutionResults.reduce((sum, targetResult) => sum + (targetResult.result?.taggedDeclarations ?? 0), 0);
-		const modifiedFiles = allFileResults.filter((entry) => entry.changed).map((entry) => entry.filePath);
-		const hookError = input.write && modifiedFiles.length > 0 ? await runTagOnAfterWriteHook(tagConfig?.onAfterWrite, modifiedFiles) : null;
-		const versionsSet = extractDistinctVersions(targetExecutionResults);
-		const distinctVersions = [...versionsSet].toSorted((left, right) => left.localeCompare(right));
-		return ok({
-			mode: input.write ? "applied" : "dry-run",
-			selectedTargets,
-			skippedPackages,
-			targetResults: targetExecutionResults,
-			filesScanned,
-			filesChanged,
-			taggedDeclarations,
-			versionSummary: summarizeVersions(versionsSet),
-			distinctVersions,
-			modifiedFiles,
-			hookError
-		});
-	} catch (caughtError) {
-		return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
-	}
-}
-async function runTagOnAfterWriteHook(hook, modifiedFiles) {
-	if (!hook || modifiedFiles.length === 0) return null;
-	try {
-		await hook({ files: modifiedFiles });
-		return null;
-	} catch (caughtHookError) {
-		return `[tag] onAfterWrite hook failed: ${messageFrom(caughtHookError)}`;
-	}
-}
-function summarizeVersions(distinctVersions) {
-	if (distinctVersions.size === 0) return "none";
-	if (distinctVersions.size > 1) return "mixed";
-	return distinctVersions.values().next().value ?? "none";
-}
-function extractDistinctVersions(targetResults) {
-	return new Set(targetResults.map((targetResult) => targetResult.result?.version).filter((version) => typeof version === "string" && version.length > 0));
-}
-function chooseWorkspacePackageTargetPath(fs, candidate) {
-	if (candidate.source !== "workspace-package") return {
-		targetPath: candidate.candidatePath,
-		source: candidate.source
-	};
-	const preferredSourceDir = path.join(candidate.candidatePath, "src");
-	try {
-		if (fs.statSync(preferredSourceDir).isDirectory()) return {
-			targetPath: preferredSourceDir,
-			source: "workspace-package-selected-src"
-		};
-	} catch {}
-	return {
-		targetPath: candidate.candidatePath,
-		source: "workspace-package-selected-root"
-	};
-}
-function resolveTargetSelection(fs, candidate, rootDir) {
-	const selectedTarget = chooseWorkspacePackageTargetPath(fs, candidate);
-	const rootRelativeTargetPath = path.relative(rootDir, selectedTarget.targetPath).split(path.sep).join("/");
-	return {
-		targetPath: selectedTarget.targetPath,
-		rootRelativeTargetPath: rootRelativeTargetPath || ".",
-		source: selectedTarget.source,
-		packageDir: candidate.packageDir,
-		packageName: candidate.packageName
-	};
-}
-/**
-* Partition tag target candidates into those to tag and those to skip, matching
-* each candidate's package name against `skipPackages` as glob patterns.
-* Candidates without a package name (e.g. an explicit-target path) are never skipped.
-*
-* @since 0.5.0-canary.0
-*/
-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
-	};
-}
-async function runOnResolvedTarget(fs, resolvedTarget, write, listener) {
-	listener?.onTargetStarted(resolvedTarget);
-	const absoluteTargetPath = path.resolve(resolvedTarget.targetPath);
-	if (!fs.existsSync(absoluteTargetPath)) {
-		const missingTargetResult = {
-			target: resolvedTarget,
-			targetExists: false,
-			runError: `Not found: ${absoluteTargetPath}`,
-			result: null
-		};
-		listener?.onTargetCompleted(resolvedTarget, missingTargetResult);
-		return missingTargetResult;
-	}
-	try {
-		const targetRunResult = {
-			target: resolvedTarget,
-			targetExists: true,
-			runError: null,
-			result: runTagOnTarget(fs, absoluteTargetPath, { write })
-		};
-		listener?.onTargetCompleted(resolvedTarget, targetRunResult);
-		return targetRunResult;
-	} catch (caughtRunError) {
-		const failedTargetRunResult = {
-			target: resolvedTarget,
-			targetExists: true,
-			runError: messageFrom(caughtRunError),
-			result: null
-		};
-		listener?.onTargetCompleted(resolvedTarget, failedTargetRunResult);
-		return failedTargetRunResult;
-	}
-}
-//#endregion
-export { filterSkippedCandidates, runTagSync };

package/dist/tag/target-candidates.mjs

@@ -1,68 +0,0 @@
-import { listWorkspacePackageDirectories } from "../core/workspace/resolver.mjs";
-import path from "node:path";
-import { z } from "zod";
-//#region src/tag/target-candidates.ts
-const packageJsonFileName = "package.json";
-const packageJsonNameSchema = z.looseObject({ name: z.string().min(1).optional() });
-function toPosix(filePath) {
-	return filePath.split(path.sep).join("/");
-}
-function readPackageName(fs, packageDir) {
-	const packageJsonPath = path.join(packageDir, packageJsonFileName);
-	if (!fs.existsSync(packageJsonPath)) return null;
-	try {
-		const rawPackageJson = fs.readFileSync(packageJsonPath, "utf8");
-		const parsedPackageJson = JSON.parse(rawPackageJson);
-		const parsedPackageName = packageJsonNameSchema.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(fs, rootDir, packageDir) {
-	const packageName = readPackageName(fs, packageDir);
-	return {
-		candidatePath: packageDir,
-		rootRelativeCandidatePath: toRootRelativePath(rootDir, packageDir),
-		source: "workspace-package",
-		packageDir,
-		packageName
-	};
-}
-/**
-* @since 0.3.16-canary.0
-*/
-async function resolveTagTargetCandidates(fs, rootDir, explicitTarget) {
-	if (explicitTarget) {
-		const resolvedExplicitTarget = path.resolve(explicitTarget);
-		return [{
-			candidatePath: resolvedExplicitTarget,
-			rootRelativeCandidatePath: toRootRelativePath(rootDir, resolvedExplicitTarget),
-			source: "explicit-target",
-			packageDir: null,
-			packageName: null
-		}];
-	}
-	const outcome = await listWorkspacePackageDirectories(rootDir, fs, true);
-	const packageDirs = [...outcome.packageDirectoryPathsAbsolute];
-	const hasWorkspaceFile = outcome.hasPnpmWorkspaceYamlFile;
-	if (packageDirs.length === 0) {
-		if (hasWorkspaceFile) return [];
-		const repoSourceDir = path.join(rootDir, "src");
-		return [{
-			candidatePath: repoSourceDir,
-			rootRelativeCandidatePath: toRootRelativePath(rootDir, repoSourceDir),
-			source: "repo-src-fallback",
-			packageDir: null,
-			packageName: null
-		}];
-	}
-	return packageDirs.map((packageDir) => toPackageTargetCandidate(fs, rootDir, packageDir));
-}
-//#endregion
-export { resolveTagTargetCandidates };

package/dist/tag/target-runner.mjs

@@ -1,26 +0,0 @@
-import { walkTsxFiles } from "../core/workspace/typescript-walk.mjs";
-import { TagSinceWriter } from "./since-writer.mjs";
-import { resolveNearestPackageVersion } from "./version-resolver.mjs";
-import path from "node:path";
-//#region src/tag/target-runner.ts
-/**
-* @since 0.3.16-canary.0
-*/
-function runTagOnTarget(fs, targetPath, opts) {
-	const resolvedTarget = path.resolve(targetPath);
-	const version = resolveNearestPackageVersion(fs, resolvedTarget);
-	const tsFiles = (fs.statSync(resolvedTarget).isDirectory() ? walkTsxFiles(resolvedTarget, fs) : [resolvedTarget]).filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
-	const sinceWriter = new TagSinceWriter(fs);
-	const fileResults = tsFiles.map((filePath) => sinceWriter.applySinceTagsToFile(filePath, version, opts.write));
-	const filesChanged = fileResults.filter((result) => result.changed).length;
-	const taggedDeclarations = fileResults.reduce((sum, result) => sum + result.taggedDeclarations, 0);
-	return {
-		version,
-		filesScanned: tsFiles.length,
-		filesChanged,
-		taggedDeclarations,
-		fileResults
-	};
-}
-//#endregion
-export { runTagOnTarget };

package/dist/tag/version-resolver.mjs

@@ -1,25 +0,0 @@
-import path from "node:path";
-//#region src/tag/version-resolver.ts
-const packageJsonFileName = "package.json";
-/**
-* @since 0.3.16-canary.0
-*/
-function resolveNearestPackageVersion(fs, targetPath) {
-	const resolved = path.resolve(targetPath);
-	let current = fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
-	while (true) {
-		const packageJsonPath = path.join(current, packageJsonFileName);
-		if (fs.existsSync(packageJsonPath)) {
-			const raw = fs.readFileSync(packageJsonPath, "utf8");
-			const version = JSON.parse(raw).version;
-			if (typeof version === "string" && version.length > 0) return version;
-			throw new Error(`Missing or invalid version in ${packageJsonPath}`);
-		}
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
-	}
-	throw new Error(`Unable to locate ${packageJsonFileName} from target: ${targetPath}`);
-}
-//#endregion
-export { resolveNearestPackageVersion };