@codefast/cli 0.3.14 → 0.3.15

package/dist/{lib → domains}/tag/application/use-cases/run-tag-sync.use-case.mjs

@@ -1,11 +1,10 @@
-import { CliFsToken, CliPathToken } from "../../../core/contracts/tokens.mjs";
-import { AppError } from "../../../core/domain/errors.domain.mjs";
-import { err, ok } from "../../../core/domain/result.model.mjs";
-import { messageFromCaughtUnknown } from "../../../core/domain/caught-unknown-message.value-object.mjs";
-import { TagSinceWriterPortToken, TagTargetResolverPortToken, TagVersionResolverPortToken, TypeScriptTreeWalkPortToken } from "../../contracts/tokens.mjs";
-import { runTagOnTarget } from "../services/tag-target-runner.service.mjs";
+import { CliFilesystemPortToken, CliPathPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { AppError } from "../../../../shell/domain/errors.domain.mjs";
+import { err, ok } from "../../../../shell/domain/result.model.mjs";
+import { messageFromCaughtUnknown } from "../../../../shell/domain/caught-unknown-message.value-object.mjs";
+import { TagEligibleWorkspacePathsPortToken, TagTargetRunnerPortToken } from "../../composition/tokens.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/tag/application/use-cases/run-tag-sync.use-case.ts
+//#region src/domains/tag/application/use-cases/run-tag-sync.use-case.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -216,155 +215,51 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-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";
-	for (const version of distinctVersions) return version;
-	return "none";
-}
-function extractDistinctVersions(targetResults) {
-	return new Set(targetResults.map((targetResult) => targetResult.result?.version).filter((version) => typeof version === "string" && version.length > 0));
-}
-function chooseWorkspacePackageTargetPath(candidate, pathService, fs) {
-	if (candidate.source !== "workspace-package") return {
-		targetPath: candidate.candidatePath,
-		source: candidate.source
-	};
-	const preferredSourceDir = pathService.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, pathService, fs) {
-	const selectedTarget = chooseWorkspacePackageTargetPath(candidate, pathService, fs);
-	const rootRelativeTargetPath = pathService.relative(rootDir, selectedTarget.targetPath).split(pathService.separator).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, pathService, versionResolver, sinceWriter, typeScriptTreeWalk, listener) {
-	listener?.onTargetStarted(resolvedTarget);
-	const absoluteTargetPath = pathService.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, pathService, versionResolver, sinceWriter, typeScriptTreeWalk)
-		};
-		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;
-	}
-}
 _dec = injectable([
-	inject(CliFsToken),
-	inject(CliPathToken),
-	inject(TagTargetResolverPortToken),
-	inject(TypeScriptTreeWalkPortToken),
-	inject(TagVersionResolverPortToken),
-	inject(TagSinceWriterPortToken)
+	inject(CliFilesystemPortToken),
+	inject(CliPathPortToken),
+	inject(TagEligibleWorkspacePathsPortToken),
+	inject(TagTargetRunnerPortToken)
 ]);
-let _RunTagSyncUseCaseImpl;
+let _RunTagSyncUseCase;
 (class {
 	fs;
 	path;
 	targetResolver;
-	typeScriptTreeWalk;
-	versionResolver;
-	sinceWriter;
+	tagTargetRunner;
 	static {
-		({c: [_RunTagSyncUseCaseImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_RunTagSyncUseCase, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fs, path, targetResolver, typeScriptTreeWalk, versionResolver, sinceWriter) {
+	constructor(fs, path, targetResolver, tagTargetRunner) {
 		this.fs = fs;
 		this.path = path;
 		this.targetResolver = targetResolver;
-		this.typeScriptTreeWalk = typeScriptTreeWalk;
-		this.versionResolver = versionResolver;
-		this.sinceWriter = sinceWriter;
+		this.tagTargetRunner = tagTargetRunner;
 	}
 	async execute(input) {
 		try {
 			const tagConfig = input.config;
-			const { includedCandidates, skippedPackages } = filterSkippedCandidates(await this.targetResolver.resolveTagTargetCandidates(input.rootDir, input.targetPath), input.skipPackages);
-			const selectedTargets = includedCandidates.map((candidate) => resolveTargetSelection(candidate, input.rootDir, this.path, this.fs));
-			const targetExecutionResults = await Promise.all(selectedTargets.map((resolvedTarget) => runOnResolvedTarget(resolvedTarget, input.write, this.fs, this.path, this.versionResolver, this.sinceWriter, this.typeScriptTreeWalk, input.listener)));
+			const targetCandidates = await this.targetResolver.resolveTagTargetCandidates(input.rootDir, input.targetPath);
+			const { includedCandidates, skippedPackages } = this.filterSkippedCandidates(targetCandidates, input.skipPackages);
+			const selectedTargets = includedCandidates.map((candidate) => this.resolveTargetSelection(candidate, input.rootDir));
+			const targetExecutionResults = await Promise.all(selectedTargets.map((resolvedTarget) => this.runOnResolvedTarget(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 distinctVersions = [...extractDistinctVersions(targetExecutionResults)].sort((left, right) => left.localeCompare(right));
+			const hookError = input.write && modifiedFiles.length > 0 ? await this.runTagOnAfterWriteHook(tagConfig?.onAfterWrite, modifiedFiles) : null;
+			const versionsSet = this.extractDistinctVersions(targetExecutionResults);
+			const distinctVersions = [...versionsSet].sort((left, right) => left.localeCompare(right));
 			return ok({
 				mode: input.write ? "applied" : "dry-run",
 				selectedTargets,
-				resolvedTargets: selectedTargets,
 				skippedPackages,
 				targetResults: targetExecutionResults,
 				filesScanned,
 				filesChanged,
 				taggedDeclarations,
-				versionSummary: summarizeVersions(targetExecutionResults),
+				versionSummary: this.summarizeVersions(versionsSet),
 				distinctVersions,
 				modifiedFiles,
 				hookError
@@ -373,9 +268,108 @@ let _RunTagSyncUseCaseImpl;
 			return err(new AppError("INFRA_FAILURE", messageFromCaughtUnknown(caughtError), caughtError));
 		}
 	}
+	async 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)}`;
+		}
+	}
+	summarizeVersions(distinctVersions) {
+		if (distinctVersions.size === 0) return "none";
+		if (distinctVersions.size > 1) return "mixed";
+		return distinctVersions.values().next().value ?? "none";
+	}
+	extractDistinctVersions(targetResults) {
+		return new Set(targetResults.map((targetResult) => targetResult.result?.version).filter((version) => typeof version === "string" && version.length > 0));
+	}
+	chooseWorkspacePackageTargetPath(candidate) {
+		if (candidate.source !== "workspace-package") return {
+			targetPath: candidate.candidatePath,
+			source: candidate.source
+		};
+		const preferredSourceDir = this.path.join(candidate.candidatePath, "src");
+		try {
+			if (this.fs.statSync(preferredSourceDir).isDirectory()) return {
+				targetPath: preferredSourceDir,
+				source: "workspace-package-selected-src"
+			};
+		} catch {}
+		return {
+			targetPath: candidate.candidatePath,
+			source: "workspace-package-selected-root"
+		};
+	}
+	resolveTargetSelection(candidate, rootDir) {
+		const selectedTarget = this.chooseWorkspacePackageTargetPath(candidate);
+		const rootRelativeTargetPath = this.path.relative(rootDir, selectedTarget.targetPath).split(this.path.separator).join("/");
+		return {
+			targetPath: selectedTarget.targetPath,
+			rootRelativeTargetPath: rootRelativeTargetPath || ".",
+			source: selectedTarget.source,
+			packageDir: candidate.packageDir,
+			packageName: candidate.packageName
+		};
+	}
+	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 runOnResolvedTarget(resolvedTarget, write, listener) {
+		listener?.onTargetStarted(resolvedTarget);
+		const absoluteTargetPath = this.path.resolve(resolvedTarget.targetPath);
+		if (!this.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: this.tagTargetRunner.runOnTarget(absoluteTargetPath, { write })
+			};
+			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;
+		}
+	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _RunTagSyncUseCaseImpl as RunTagSyncUseCaseImpl };
+export { _RunTagSyncUseCase as RunTagSyncUseCase };

package/dist/domains/tag/composition/tokens.mjs

@@ -0,0 +1,13 @@
+import { token } from "@codefast/di";
+//#region src/domains/tag/composition/tokens.ts
+const TagEligibleWorkspacePathsPortToken = token("TagEligibleWorkspacePathsPort");
+const TagSinceWriterPortToken = token("TagSinceWriterPort");
+const TagVersionResolverPortToken = token("TagVersionResolverPort");
+const RunTagSyncUseCaseToken = token("RunTagSyncUseCase");
+const PrepareTagSyncUseCaseToken = token("PrepareTagSyncUseCase");
+const TagTargetRunnerPortToken = token("TagTargetRunnerPort");
+const TagTargetPathResolverPortToken = token("TagTargetPathResolverPort");
+const PresentTagSyncResultPresenterToken = token("PresentTagSyncResultPresenter");
+const PresentTagSyncProgressPresenterToken = token("PresentTagSyncProgressPresenter");
+//#endregion
+export { PrepareTagSyncUseCaseToken, PresentTagSyncProgressPresenterToken, PresentTagSyncResultPresenterToken, RunTagSyncUseCaseToken, TagEligibleWorkspacePathsPortToken, TagSinceWriterPortToken, TagTargetPathResolverPortToken, TagTargetRunnerPortToken, TagVersionResolverPortToken };

package/dist/domains/tag/contracts/models.mjs

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

package/dist/domains/tag/domain/types.domain.mjs

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

package/dist/{lib/tag/adapters/secondary → domains/tag/infrastructure/adapters}/tag-since-writer.adapter.mjs

@@ -1,8 +1,8 @@
-import { CliFsToken } from "../../../core/contracts/tokens.mjs";
-import { applyEditsDescending, indentOfLineContaining } from "../../../shared/source-code/domain/text-edit.model.mjs";
+import { CliFilesystemPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { applyEditsDescending, indentOfLineContaining } from "../../../../shell/domain/source-text-edit.support.mjs";
 import { inject, injectable } from "@codefast/di";
 import ts from "typescript";
-//#region src/lib/tag/adapters/secondary/tag-since-writer.adapter.ts
+//#region src/domains/tag/infrastructure/adapters/tag-since-writer.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -213,106 +213,7 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-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;
-	}
-	const bucket = registry.get(name);
-	if (bucket === void 0) throw new Error(`declaration registry missing set for ${name}`);
-	bucket.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;
-	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}`
-	};
-}
-_dec = injectable([inject(CliFsToken)]);
+_dec = injectable([inject(CliFilesystemPortToken)]);
 let _TagSinceWriterAdapter;
 (class {
 	fs;
@@ -322,12 +223,13 @@ let _TagSinceWriterAdapter;
 	constructor(fs) {
 		this.fs = fs;
 	}
+	sinceDocumentationTag = "@since";
 	applySinceTagsToFile(filePath, version, write) {
 		const sourceText = this.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);
+		for (const declaration of this.collectExportedDeclarations(sf)) {
+			const edit = this.makeDeclarationSinceLine(declaration, sf, sourceText, version);
 			if (edit) edits.push(edit);
 		}
 		if (edits.length > 0 && write) {
@@ -340,6 +242,104 @@ let _TagSinceWriterAdapter;
 			changed: edits.length > 0
 		};
 	}
+	hasExportModifier(node) {
+		return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+	}
+	isTaggableDeclaration(node) {
+		return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
+	}
+	addDeclarationName(registry, name, declaration) {
+		if (!registry.has(name)) {
+			registry.set(name, new Set([declaration]));
+			return;
+		}
+		const bucket = registry.get(name);
+		if (bucket === void 0) throw new Error(`declaration registry missing set for ${name}`);
+		bucket.add(declaration);
+	}
+	collectLocalNamedDeclarations(sf) {
+		const declarations = /* @__PURE__ */ new Map();
+		for (const statement of sf.statements) {
+			if (ts.isFunctionDeclaration(statement) && statement.name) {
+				this.addDeclarationName(declarations, statement.name.text, statement);
+				continue;
+			}
+			if (ts.isClassDeclaration(statement) && statement.name) {
+				this.addDeclarationName(declarations, statement.name.text, statement);
+				continue;
+			}
+			if (ts.isInterfaceDeclaration(statement)) {
+				this.addDeclarationName(declarations, statement.name.text, statement);
+				continue;
+			}
+			if (ts.isTypeAliasDeclaration(statement)) {
+				this.addDeclarationName(declarations, statement.name.text, statement);
+				continue;
+			}
+			if (ts.isEnumDeclaration(statement)) {
+				this.addDeclarationName(declarations, statement.name.text, statement);
+				continue;
+			}
+			if (!ts.isVariableStatement(statement)) continue;
+			for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) this.addDeclarationName(declarations, declaration.name.text, statement);
+		}
+		return declarations;
+	}
+	collectExportedDeclarations(sf) {
+		const exported = /* @__PURE__ */ new Set();
+		const localNamed = this.collectLocalNamedDeclarations(sf);
+		for (const statement of sf.statements) {
+			if (this.isTaggableDeclaration(statement) && this.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;
+	}
+	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} * ${this.sinceDocumentationTag} ${version}\n${baseIndent} */`;
+		return {
+			start: existingComment.pos,
+			end: existingComment.end,
+			replacement
+		};
+	}
+	makeSinceOnlyJSDocBlock(declarationIndent, version) {
+		return `/**\n${declarationIndent} * ${this.sinceDocumentationTag} ${version}\n${declarationIndent} */`;
+	}
+	makeDeclarationSinceLine(declaration, sf, sourceText, version) {
+		if (ts.getJSDocTags(declaration).some((tag) => tag.tagName.text === "since")) return;
+		const lastJsDoc = ts.getJSDocCommentsAndTags(declaration).filter(ts.isJSDoc).at(-1);
+		if (lastJsDoc) return this.makeJSDocSinceLine(lastJsDoc, sourceText, version);
+		const start = declaration.getStart(sf);
+		const indent = indentOfLineContaining(sourceText, start);
+		return {
+			start,
+			end: start,
+			replacement: `${indent}${this.makeSinceOnlyJSDocBlock(indent, version)}\n${indent}`
+		};
+	}
 	static {
 		_initClass();
 	}

package/dist/{lib/tag/adapters/secondary/typescript-tree-walk.adapter.mjs → domains/tag/infrastructure/adapters/tag-target-path-resolver.adapter.mjs}

@@ -1,7 +1,7 @@
-import { CliFsToken } from "../../../core/contracts/tokens.mjs";
-import { walkTsxFiles } from "../../../shared/source-code/infrastructure/typescript-source-file-walker.service.mjs";
+import { CliFilesystemPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import path from "node:path";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/tag/adapters/secondary/typescript-tree-walk.adapter.ts
+//#region src/domains/tag/infrastructure/adapters/tag-target-path-resolver.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -212,22 +212,24 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([inject(CliFsToken)]);
-let _TypeScriptTreeWalkAdapter;
+_dec = injectable([inject(CliFilesystemPortToken)]);
+let _TagTargetPathResolverAdapter;
 (class {
 	fs;
 	static {
-		({c: [_TypeScriptTreeWalkAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_TagTargetPathResolverAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
 	constructor(fs) {
 		this.fs = fs;
 	}
-	walkTsxFiles(rootDirectoryPath) {
-		return walkTsxFiles(rootDirectoryPath, this.fs);
+	resolveProvidedTargetPath(args) {
+		if (args.rawTarget === void 0) return;
+		const candidate = path.isAbsolute(args.rawTarget) ? path.resolve(args.rawTarget) : path.resolve(args.currentWorkingDirectory, args.rawTarget);
+		return this.fs.canonicalPathSync(candidate);
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _TypeScriptTreeWalkAdapter as TypeScriptTreeWalkAdapter };
+export { _TagTargetPathResolverAdapter as TagTargetPathResolverAdapter };