@codefast/cli 0.3.7-canary.0 → 0.3.13-canary.0

package/dist/constants-AtPhF-Ct.mjs

@@ -0,0 +1,169 @@
+//#region src/lib/arrange/domain/constants.ts
+/** Analyze report: long literal threshold (token count). */
+const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+* Minimum token count for a string to be considered a candidate for grouping
+* in the apply/preview pipeline. Intentionally much lower than
+* {@link LONG_STRING_TOKEN_THRESHOLD} (analyze only).
+*/
+const APPLY_MIN_TOKENS = 2;
+/**
+* Minimum tokens a group must have to stand alone before singleton-merging.
+* Set to 2 so single-token groups are not collapsed into unrelated buckets by the merger.
+*/
+const MIN_GROUP_TOKENS = 2;
+/** Dynamic max groups clamp: base bound. */
+const MAX_GROUPS_BASE = 4;
+/** Dynamic max groups clamp: upper cap. */
+const MAX_GROUPS_CAP = 24;
+/**
+* Extra slots so a few state / aria groups do not force `capGroups` to merge
+* unrelated buckets (e.g. `bg-border` + `outline-hidden`).
+*/
+const MAX_GROUPS_HEADROOM = 2;
+/** Maximum findings printed per category in the analyze report. */
+const MAX_REPORT_LINES = 40;
+/** Maximum recursion depth when traversing `tv()` object literals. */
+const MAX_OBJECT_DEPTH = 12;
+/** Maximum depth when peeling conditional / parens / arrays inside `cn(...)` args. */
+const MAX_CLASS_EXPR_DEPTH = 12;
+/**
+* Maximum variant-stripping passes in {@link stripVariants}.
+* Real-world Tailwind stacks rarely exceed 4–5 segments (e.g. `@md/sidebar:group-hover:dark:focus-visible:`);
+* 12 is a conservative safety cap that prevents runaway loops on malformed input.
+*/
+const MAX_STRIP_VARIANT_PASSES = 12;
+/**
+* Passed when optional `knownBindings` is missing — size 0 disables matching
+* for `cn` / `tv` identifier resolution.
+*/
+const EMPTY_CN_TV_BINDINGS = /* @__PURE__ */ new Set();
+/**
+* Bucket sort order — **render pipeline** (lower → earlier in output).
+* Existence → Position → Layout → Sizing → Spacing → Shape → Background → Shadow
+* → Typography → Composite → Motion → Starting → Behavior → State (variants) → Selector variants.
+*/
+const BUCKET_ORDER = {
+	existence: 0,
+	position: 1,
+	layout: 2,
+	sizing: 3,
+	spacing: 4,
+	shape: 5,
+	background: 6,
+	shadow: 7,
+	typography: 8,
+	composite: 9,
+	motion: 10,
+	starting: 11,
+	behavior: 12,
+	state: 13,
+	selector: 14,
+	other: 15,
+	arbitrary: 16
+};
+/**
+* Compatible bucket **pairs** — two adjacent tokens whose buckets appear in the same
+* `Set` may stay in one `cn()` string chunk. Compatibility is **not transitive**: there is
+* no `{position, sizing}` pair, so `fixed inset-0` and `overflow-auto` become **separate**
+* literals unless **layout** tokens sit between them in sorted order; then
+* `position↔layout` and `layout↔sizing` each justify one hop and the whole “box in flow”
+* (place + tracks + scrollport) stays in one chunk — co-located because they jointly define
+* stacking and scroll behavior for the same surface.
+*/
+const COMPATIBLE_BUCKET_SETS = [
+	new Set(["existence", "position"]),
+	new Set(["existence", "layout"]),
+	new Set(["position", "layout"]),
+	new Set(["layout", "sizing"]),
+	new Set(["shape", "shadow"]),
+	new Set(["background", "shadow"]),
+	new Set(["background", "typography"]),
+	new Set(["layout", "typography"]),
+	new Set(["sizing", "typography"]),
+	new Set(["motion", "behavior"]),
+	new Set(["motion", "starting"]),
+	new Set(["composite", "motion"]),
+	new Set(["sizing", "composite"]),
+	new Set(["sizing", "spacing"])
+];
+/**
+* Responsive / variant prefix — Tailwind v4 aware.
+*
+* v3: sm: md: … — v4: @sm:, @min-[600px]:, @[480px]:, named @md/sidebar:,
+* viewport md/sidebar:, min-[100px]: / max-[100px]:, …
+*/
+const RESPONSIVE_PREFIX = /^(?:@(?:min|max)-\[[^\]]+\]:|@\[[^\]]+\]:|@(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/[a-z][a-z0-9-]*)?:|(?:max-|min-)?(?:sm|md|lg|xl|2xl|3xl)(?:\/[a-z][a-z0-9-]*)?:|(?:max-|min-)\[[^\]]+\]:)/;
+/** State variant stems — hoisted to module scope (not recreated per call). */
+const STATE_PREFIXES = new Set([
+	"hover",
+	"focus",
+	"focus-within",
+	"focus-visible",
+	"active",
+	"visited",
+	"link",
+	"any-link",
+	"disabled",
+	"enabled",
+	"checked",
+	"indeterminate",
+	"required",
+	"optional",
+	"valid",
+	"invalid",
+	"in-range",
+	"out-of-range",
+	"read-only",
+	"read-write",
+	"placeholder-shown",
+	"default",
+	"autofill",
+	"open",
+	"closed",
+	"first",
+	"last",
+	"only",
+	"odd",
+	"even",
+	"first-of-type",
+	"last-of-type",
+	"only-of-type",
+	"first-child",
+	"last-child",
+	"only-child",
+	"empty",
+	"target",
+	"group",
+	"peer",
+	"aria",
+	"data",
+	"dark",
+	"light",
+	"supports",
+	"motion-reduce",
+	"motion-safe",
+	"print",
+	"screen",
+	"ltr",
+	"rtl",
+	"not",
+	"has",
+	"in",
+	"nth",
+	"file",
+	"selection",
+	"marker",
+	"placeholder",
+	"before",
+	"after",
+	"first-line",
+	"first-letter",
+	"backdrop",
+	"details-content",
+	"popover-open"
+]);
+/** Default directory for arrange analyze/preview/apply when no target is passed. */
+const DEFAULT_ARRANGE_TARGET = "packages/ui/src/components";
+//#endregion
+export { EMPTY_CN_TV_BINDINGS as a, MAX_GROUPS_BASE as c, MAX_OBJECT_DEPTH as d, MAX_REPORT_LINES as f, STATE_PREFIXES as g, RESPONSIVE_PREFIX as h, DEFAULT_ARRANGE_TARGET as i, MAX_GROUPS_CAP as l, MIN_GROUP_TOKENS as m, BUCKET_ORDER as n, LONG_STRING_TOKEN_THRESHOLD as o, MAX_STRIP_VARIANT_PASSES as p, COMPATIBLE_BUCKET_SETS as r, MAX_CLASS_EXPR_DEPTH as s, APPLY_MIN_TOKENS as t, MAX_GROUPS_HEADROOM as u };

package/dist/constants-Bq5wdyLC.mjs

@@ -0,0 +1,8 @@
+//#region src/lib/mirror/domain/constants.ts
+const DIST_DIR = "dist";
+const PACKAGE_JSON = "package.json";
+const VALID_JS_EXTENSIONS = new Set([".js", ".cjs"]);
+const DTS_EXTENSION = ".d.ts";
+const PACKAGE_JSON_EXPORT = "./package.json";
+//#endregion
+export { VALID_JS_EXTENSIONS as a, PACKAGE_JSON_EXPORT as i, DTS_EXTENSION as n, PACKAGE_JSON as r, DIST_DIR as t };

package/dist/dirent-list-BSDeRG5i.mjs

@@ -0,0 +1,14 @@
+//#region src/lib/mirror/infra/dirent-list.ts
+/**
+* Narrow `fs.promises.readdir` overload result to `Dirent[]` when `withFileTypes: true`.
+* Accepts both historical checks (`isFile` / `isDirectory`) in one guard.
+* Returning `true` for an empty array is intentional: callers treat empty lists
+* the same regardless of the element type, so `[]` is safely accepted as `Dirent[]`.
+*/
+function isDirentList(x) {
+	if (x.length === 0) return true;
+	const first = x[0];
+	return typeof first === "object" && first !== null && "isFile" in first && "isDirectory" in first;
+}
+//#endregion
+export { isDirentList as t };

package/dist/engine-CcWEHSCq.mjs

@@ -0,0 +1,287 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { i as indentOfLineContaining, n as applyEditsDescending } from "./ast-helpers-MDRYuIAk.mjs";
+import { n as walkTsxFiles } from "./walk-DjgQn66n.mjs";
+import "./arrange-BqP2DI3w.mjs";
+import { t as resolveTagTargetCandidates } from "./target-resolver-CR3FXMTy.mjs";
+import path from "node:path";
+import ts from "typescript";
+//#region src/lib/tag/application/engine.ts
+const PACKAGE_JSON = "package.json";
+const VERSION_TAG = "@since";
+function hasExportModifier(node) {
+	return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isTaggableDeclaration(node) {
+	return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
+}
+function addDeclarationName(registry, name, declaration) {
+	if (!registry.has(name)) {
+		registry.set(name, new Set([declaration]));
+		return;
+	}
+	registry.get(name).add(declaration);
+}
+function collectLocalNamedDeclarations(sf) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const statement of sf.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isClassDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isInterfaceDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isTypeAliasDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isEnumDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) addDeclarationName(declarations, declaration.name.text, statement);
+	}
+	return declarations;
+}
+function collectExportedDeclarations(sf) {
+	const exported = /* @__PURE__ */ new Set();
+	const localNamed = collectLocalNamedDeclarations(sf);
+	for (const statement of sf.statements) {
+		if (isTaggableDeclaration(statement) && hasExportModifier(statement)) {
+			exported.add(statement);
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) {
+				const localName = element.propertyName?.text ?? element.name.text;
+				const declarations = localNamed.get(localName);
+				if (!declarations) continue;
+				for (const declaration of declarations) exported.add(declaration);
+			}
+			continue;
+		}
+		if (!ts.isExportAssignment(statement) || !ts.isIdentifier(statement.expression)) continue;
+		const declarations = localNamed.get(statement.expression.text);
+		if (!declarations) continue;
+		for (const declaration of declarations) exported.add(declaration);
+	}
+	return exported;
+}
+function makeJSDocSinceLine(existingComment, sourceText, version) {
+	const commentText = sourceText.slice(existingComment.pos, existingComment.end);
+	const baseIndent = indentOfLineContaining(sourceText, existingComment.pos);
+	const normalizedBodyLines = commentText.replace(/^\/\*\*\s?/, "").replace(/\s*\*\/$/, "").split("\n").map((line) => line.replace(/^\s*\*\s?/, "").replace(/\s+$/, "")).filter((line, lineIndex, lines) => {
+		if (line.length > 0) return true;
+		const hasNonEmptyBefore = lines.slice(0, lineIndex).some((value) => value.length > 0);
+		const hasNonEmptyAfter = lines.slice(lineIndex + 1).some((value) => value.length > 0);
+		return hasNonEmptyBefore && hasNonEmptyAfter;
+	});
+	const replacement = `/**\n${normalizedBodyLines.length > 0 ? `${normalizedBodyLines.map((line) => `${baseIndent} * ${line}`).join("\n")}\n${baseIndent} *\n` : ""}${baseIndent} * ${VERSION_TAG} ${version}\n${baseIndent} */`;
+	return {
+		start: existingComment.pos,
+		end: existingComment.end,
+		replacement
+	};
+}
+function makeSinceOnlyJSDocBlock(declarationIndent, version) {
+	return `/**\n${declarationIndent} * ${VERSION_TAG} ${version}\n${declarationIndent} */`;
+}
+function makeDeclarationSinceLine(declaration, sf, sourceText, version) {
+	if (ts.getJSDocTags(declaration).some((tag) => tag.tagName.text === "since")) return void 0;
+	const lastJsDoc = ts.getJSDocCommentsAndTags(declaration).filter(ts.isJSDoc).at(-1);
+	if (lastJsDoc) return makeJSDocSinceLine(lastJsDoc, sourceText, version);
+	const start = declaration.getStart(sf);
+	const indent = indentOfLineContaining(sourceText, start);
+	return {
+		start,
+		end: start,
+		replacement: `${indent}${makeSinceOnlyJSDocBlock(indent, version)}\n${indent}`
+	};
+}
+function applySinceTagsToFile(filePath, version, fs, write) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const edits = [];
+	for (const declaration of collectExportedDeclarations(sf)) {
+		const edit = makeDeclarationSinceLine(declaration, sf, sourceText, version);
+		if (edit) edits.push(edit);
+	}
+	if (edits.length > 0 && write) {
+		const updated = applyEditsDescending(sourceText, edits);
+		fs.writeFileSync(filePath, updated, "utf8");
+	}
+	return {
+		filePath,
+		taggedDeclarations: edits.length,
+		changed: edits.length > 0
+	};
+}
+function resolveNearestPackageVersion(targetPath, fs) {
+	const resolved = path.resolve(targetPath);
+	let current = fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+	while (true) {
+		const packageJsonPath = path.join(current, PACKAGE_JSON);
+		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 ${PACKAGE_JSON} from target: ${targetPath}`);
+}
+function runTagOnTarget(targetPath, opts, fs) {
+	const resolvedTarget = path.resolve(targetPath);
+	const version = resolveNearestPackageVersion(resolvedTarget, fs);
+	const tsFiles = (fs.statSync(resolvedTarget).isDirectory() ? walkTsxFiles(resolvedTarget, fs) : [resolvedTarget]).filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+	const fileResults = tsFiles.map((filePath) => applySinceTagsToFile(filePath, version, fs, 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
+	};
+}
+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: ${messageFromCaughtUnknown(caughtHookError)}`;
+	}
+}
+function summarizeVersions(targetResults) {
+	const distinctVersions = extractDistinctVersions(targetResults);
+	if (distinctVersions.size === 0) return "none";
+	if (distinctVersions.size > 1) return "mixed";
+	return [...distinctVersions][0];
+}
+function extractDistinctVersions(targetResults) {
+	return new Set(targetResults.map((targetResult) => targetResult.result?.version).filter((version) => typeof version === "string" && version.length > 0));
+}
+function chooseWorkspacePackageTargetPath(candidate, fs) {
+	if (candidate.source !== "workspace-package") return {
+		targetPath: candidate.candidatePath,
+		source: candidate.source
+	};
+	const preferredSourceDir = path.join(candidate.candidatePath, "src");
+	if (fs.existsSync(preferredSourceDir) && fs.statSync(preferredSourceDir).isDirectory()) return {
+		targetPath: preferredSourceDir,
+		source: "workspace-package-selected-src"
+	};
+	return {
+		targetPath: candidate.candidatePath,
+		source: "workspace-package-selected-root"
+	};
+}
+function resolveTargetSelection(candidate, rootDir, fs) {
+	const selectedTarget = chooseWorkspacePackageTargetPath(candidate, fs);
+	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
+	};
+}
+function filterSkippedCandidates(targetCandidates, skipPackages) {
+	if (!skipPackages || skipPackages.length === 0) return {
+		includedCandidates: targetCandidates,
+		skippedPackages: []
+	};
+	const skipPackageSet = new Set(skipPackages);
+	const includedCandidates = [];
+	const skippedPackages = [];
+	for (const candidate of targetCandidates) {
+		const packageName = candidate.packageName;
+		if (packageName && skipPackageSet.has(packageName)) {
+			skippedPackages.push(packageName);
+			continue;
+		}
+		includedCandidates.push(candidate);
+	}
+	return {
+		includedCandidates,
+		skippedPackages
+	};
+}
+async function runOnResolvedTarget(resolvedTarget, write, fs, 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(absoluteTargetPath, { write }, fs)
+		};
+		listener?.onTargetCompleted(resolvedTarget, targetRunResult);
+		return targetRunResult;
+	} catch (caughtRunError) {
+		const failedTargetRunResult = {
+			target: resolvedTarget,
+			targetExists: true,
+			runError: messageFromCaughtUnknown(caughtRunError),
+			result: null
+		};
+		listener?.onTargetCompleted(resolvedTarget, failedTargetRunResult);
+		return failedTargetRunResult;
+	}
+}
+/**
+* CLI entry: run tagging and optional `onAfterWrite` using config injected by the command layer.
+* Returns structured execution data; presentation/logging belongs to command layer.
+*/
+async function runTagSync(opts) {
+	const { fs } = opts;
+	const { includedCandidates, skippedPackages } = filterSkippedCandidates(await resolveTagTargetCandidates(opts.rootDir, opts.targetPath, fs), opts.skipPackages);
+	const selectedTargets = includedCandidates.map((candidate) => resolveTargetSelection(candidate, opts.rootDir, fs));
+	const targetResults = await Promise.all(selectedTargets.map((resolvedTarget) => runOnResolvedTarget(resolvedTarget, opts.write, fs, opts.listener)));
+	const allFileResults = targetResults.flatMap((targetResult) => targetResult.result?.fileResults ?? []);
+	const filesScanned = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesScanned ?? 0), 0);
+	const filesChanged = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesChanged ?? 0), 0);
+	const taggedDeclarations = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.taggedDeclarations ?? 0), 0);
+	const modifiedFiles = allFileResults.filter((entry) => entry.changed).map((entry) => entry.filePath);
+	const hookError = opts.write && modifiedFiles.length > 0 ? await runTagOnAfterWriteHook(opts.config?.onAfterWrite, modifiedFiles) : null;
+	const distinctVersions = [...extractDistinctVersions(targetResults)].sort((left, right) => left.localeCompare(right));
+	return {
+		mode: opts.write ? "applied" : "dry-run",
+		selectedTargets,
+		resolvedTargets: selectedTargets,
+		skippedPackages,
+		targetResults,
+		filesScanned,
+		filesChanged,
+		taggedDeclarations,
+		versionSummary: summarizeVersions(targetResults),
+		distinctVersions,
+		modifiedFiles,
+		hookError
+	};
+}
+//#endregion
+export { runTagOnTarget as n, runTagSync as r, resolveNearestPackageVersion as t };