@cmflow/atlas 3.4.0-beta.29 → 3.4.0-beta.30

package/dist/bin/atlas.mjs

@@ -2,9 +2,9 @@
 import { fileURLToPath as __atlasFileURLToPath } from "node:url";
 const __filename = __atlasFileURLToPath(import.meta.url);
 import { n as __require, r as __toESM, t as __commonJSMin } from "../rolldown-runtime-CGR6nZuH.mjs";
-import { a as note, c as select, d as setUserConfig, f as userConfig$1, i as log, l as isCancel, n as cancel, o as outro, r as intro, s as progress, t as taskProgressService, u as getUserConfig } from "../taskProgressService-BRoIJQbK.mjs";
-import { a as resolveModulePath, c as filterAnalysisFiles, d as globby, i as matchesRouteSelector, l as shouldKeepAnalysisFile, n as generateBackendTopologyArtifactsInWorkers, o as inferBackendNameFromFile, s as isKnownBackendType, u as normalizeFilePath } from "../routeBackendTopologyService-NPO-ZHyY.mjs";
-import { a as loadOpenApiDocument, i as extractOpenApiOutputProperties, r as extractOpenApiInputProperties, t as require_dist$1 } from "../dist-uTuN89Bv.mjs";
+import { a as isCancel, c as userConfig$1, i as select, n as atlasLogger, o as getUserConfig, r as progress, s as setUserConfig, t as taskProgressService } from "../taskProgressService-BTXcmKRN.mjs";
+import { a as resolveModulePath, c as filterAnalysisFiles, d as globby, i as matchesRouteSelector, l as shouldKeepAnalysisFile, n as generateBackendTopologyArtifactsInWorkers, o as inferBackendNameFromFile, s as isKnownBackendType, u as normalizeFilePath } from "../routeBackendTopologyService-DMzDLqUR.mjs";
+import { a as loadOpenApiDocument, i as extractOpenApiOutputProperties, r as extractOpenApiInputProperties, t as require_dist$1 } from "../dist-KClmoDrs.mjs";
 import { n as require_auth_errors, r as require_token_error, t as require_token_util } from "../token-util-Dnzm6rU4.mjs";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
@@ -5525,7 +5525,7 @@ function createPushStepClassifier() {
 	};
 }
 var push_default = (program) => void program.command("push").argument("[catalogue-directory-or-route]", "Directory or route such as \"GET /v1/offers\"").option("--route <route>", "Push one route only, for example \"POST /v0/accommodations_arrangement/check\"").option("--update", "Persist changes to Directus", false).description("Push generated per-route YAML documents to Directus").action(async (catalogueDirectoryOrRoute, options) => {
-	intro("Datasource catalogue push");
+	atlasLogger.intro("Datasource catalogue push");
 	const { cwd } = getUserConfig();
 	const progress = taskProgressService.createStepProgress(createPushStepClassifier());
 	const update = options.update;
@@ -5541,7 +5541,7 @@ var push_default = (program) => void program.command("push").argument("[catalogu
 			write: update
 		}));
 		progress.finish(update ? "Directus synchronization completed" : "Directus dry-run completed");
-		note([
+		atlasLogger.note([
 			`Input directory: ${pushResult.inputPath}`,
 			`Route documents: ${pushResult.files.length}`,
 			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null,
@@ -5549,10 +5549,10 @@ var push_default = (program) => void program.command("push").argument("[catalogu
 			`Items processed: ${pushResult.result.pushedItems}`,
 			`Warnings: ${pushResult.result.warnings.length}`
 		].filter(Boolean).join("\n"), "Directus");
-		outro("Datasource catalogue push completed");
+		atlasLogger.outro("Datasource catalogue push completed");
 	} catch (error) {
 		progress.fail("Directus push failed");
-		cancel(formatPushError(error));
+		atlasLogger.error(formatPushError(error));
 		process.exit(1);
 	}
 });
@@ -5560,7 +5560,7 @@ var push_default = (program) => void program.command("push").argument("[catalogu
 //#endregion
 //#region src/commands/cleanOrphans.ts
 var cleanOrphans_default = (program) => void program.command("clean-orphans").option("--directus-url <url>", "Directus base URL").option("--directus-token <token>", "Directus bearer token").option("--write", "Remove the orphaned links", false).description("Find and optionally remove orphaned property-to-backend-property links in Directus").action(async (options) => {
-	intro("Datasource catalogue orphan cleanup");
+	atlasLogger.intro("Datasource catalogue orphan cleanup");
 	const progress = taskProgressService.createStepProgress();
 	try {
 		const config = getUserConfig();
@@ -5573,15 +5573,15 @@ var cleanOrphans_default = (program) => void program.command("clean-orphans").op
 			dryRun: !options.write
 		}));
 		progress.finish(options.write ? "Orphaned property links removed" : "Orphaned property links inspected");
-		note([
+		atlasLogger.note([
 			`Orphaned links found: ${result.orphanedLinks}`,
 			`Orphaned links removed: ${result.removedOrphanedLinks}`,
 			options.write ? null : "Run again with --write to remove them."
 		].filter(Boolean).join("\n"), "Directus");
-		outro("Datasource catalogue orphan cleanup completed");
+		atlasLogger.outro("Datasource catalogue orphan cleanup completed");
 	} catch (error) {
 		progress.fail("Orphan cleanup failed");
-		cancel(formatPushError(error));
+		atlasLogger.error(formatPushError(error));
 		process.exit(1);
 	}
 });
@@ -5610,10 +5610,11 @@ async function listBackendSourceMetadata(sources, backend, refresh = false) {
 	}));
 }
 var backendSources_default = (program) => void program.command("backend-sources").alias("backend-source").option("--backend <name>", "Only execute one backend source").option("--all", "Execute every configured backend source without prompting").option("--refresh", "Bypass backend source caches and rewrite them").description("Execute configured backend sources and display their resolved property metadata").action(async (options) => {
-	intro("Atlas backend source metadata");
+	atlasLogger.intro("Atlas backend source metadata");
 	try {
 		if (options.backend && options.all) throw new Error("Specify either --backend or --all, not both");
 		const sources = getUserConfig().analysis.backends.filter((source) => Boolean(source.resolve) && (!options.refresh || Boolean(source.cache)));
+		if (atlasLogger.isCi && !options.all && !options.backend) throw new Error("Specify --backend or --all when CI=1");
 		const selectedBackend = options.all ? void 0 : options.backend || await select({
 			message: "Which backend source do you want to execute?",
 			options: sources.map((source) => ({
@@ -5623,15 +5624,15 @@ var backendSources_default = (program) => void program.command("backend-sources"
 			}))
 		});
 		if (isCancel(selectedBackend)) {
-			cancel("Backend source execution cancelled");
+			atlasLogger.error("Backend source execution cancelled");
 			process.exitCode = 1;
 			return;
 		}
 		const metadata = await listBackendSourceMetadata(sources, selectedBackend, options.refresh);
-		log.message(JSON.stringify(metadata, null, 2));
-		outro("Backend source metadata generated");
+		atlasLogger.info(JSON.stringify(metadata, null, 2));
+		atlasLogger.outro("Backend source metadata generated");
 	} catch (error) {
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exitCode = 1;
 	}
 });
@@ -5741,7 +5742,7 @@ async function writeBackendMetadataArtifacts(params) {
 //#endregion
 //#region src/commands/generate.ts
 async function generateHandler(cwd, routeArgument, options) {
-	intro("Datasource catalogue generation");
+	atlasLogger.intro("Datasource catalogue generation");
 	const progress$3 = taskProgressService.createStepProgress();
 	const routeSelector = parseRouteSelector(routeArgument);
 	const profile = createAnalysisProfile(Boolean(options.profile));
@@ -5778,13 +5779,13 @@ async function generateHandler(cwd, routeArgument, options) {
 		const totalRoutes = routeSelector ? 1 : Object.values(openApiDocument.paths || {}).reduce((total, pathItem) => total + Object.keys(pathItem || {}).filter((method) => /^(get|post|put|patch|delete|head|options)$/i.test(method)).length, 0);
 		const analysisStartedAt = performance.now();
 		progress$3.finish("OpenAPI contract loaded");
-		const analysisProgress = progress({
+		const analysisProgress = atlasLogger.isCi ? void 0 : progress({
 			style: "heavy",
 			max: totalRoutes,
 			size: 40
 		});
 		let analyzedRoutes = 0;
-		analysisProgress.start(`Analyzing · [0/${totalRoutes}] routes`);
+		analysisProgress?.start(`Analyzing · [0/${totalRoutes}] routes`);
 		const documents = await analyzeCodebaseRouteContracts({
 			cwd,
 			openApiDocument,
@@ -5801,13 +5802,13 @@ async function generateHandler(cwd, routeArgument, options) {
 			onDocument: async (document) => {
 				const artifactStartedAt = performance.now();
 				analyzedRoutes += 1;
-				analysisProgress.advance(1, `Analyzing · [${analyzedRoutes}/${totalRoutes}] routes · ${document.method} ${document.path} ...`);
+				analysisProgress?.advance(1, `Analyzing · [${analyzedRoutes}/${totalRoutes}] routes · ${document.method} ${document.path} ...`);
 				const routeCatalogue = await buildCatalogue([document]);
 				await writeRouteReviewDocument(routeCatalogue, outputDir, process.cwd(), document.key);
 				profile.add("Artifacts", performance.now() - artifactStartedAt);
 			}
 		});
-		analysisProgress.stop("Static route analysis completed");
+		analysisProgress?.stop("Static route analysis completed");
 		profile.add("Static analysis", performance.now() - analysisStartedAt);
 		const catalogueStartedAt = performance.now();
 		const catalogue = await progress$3.run({
@@ -5817,17 +5818,17 @@ async function generateHandler(cwd, routeArgument, options) {
 			detail: `${documents.length} route${documents.length === 1 ? "" : "s"}`
 		}, () => buildCatalogue(documents));
 		profile.add("Catalogue build", performance.now() - catalogueStartedAt);
-		note([
+		atlasLogger.note([
 			`Output directory: ${outputDir}`,
 			`Route documents: ${catalogue.routes.length}`,
 			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null
 		].filter(Boolean).join("\n"), "Artifacts");
-		note(JSON.stringify(catalogue.stats, null, 2), "Stats");
-		if (options.profile) note(profile.report().join("\n"), "Performance profile");
-		outro("Datasource catalogue generation completed");
+		atlasLogger.note(JSON.stringify(catalogue.stats, null, 2), "Stats");
+		if (options.profile) atlasLogger.note(profile.report().join("\n"), "Performance profile");
+		atlasLogger.outro("Datasource catalogue generation completed");
 	} catch (error) {
 		progress$3.fail("Generation failed");
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 }
@@ -5851,7 +5852,7 @@ function parsePositiveInteger(value, message = "Expected a positive integer") {
 //#region src/commands/generateGraph.ts
 const parseWorkerCount$1 = (value) => parsePositiveInteger(value, "Worker count must be a positive integer");
 async function generateGraphHandler(cwd, routeArgument, options) {
-	intro("Code source Graph generation");
+	atlasLogger.intro("Code source Graph generation");
 	const progress$2 = taskProgressService.createStepProgress((message) => {
 		if (message === "Discovering route files") return {
 			id: "route-files",
@@ -5894,12 +5895,14 @@ async function generateGraphHandler(cwd, routeArgument, options) {
 		let routeProgress;
 		const onRoutesDiscovered = (total) => {
 			progress$2.finish("Route declarations extracted");
-			routeProgress = progress({
-				style: "heavy",
-				max: total,
-				size: 40
-			});
-			routeProgress.start(`${workerCount} worker${workerCount > 1 ? "s" : ""} · Graph · [0/${total}] routes`);
+			if (!atlasLogger.isCi) {
+				routeProgress = progress({
+					style: "heavy",
+					max: total,
+					size: 40
+				});
+				routeProgress.start(`${workerCount} worker${workerCount > 1 ? "s" : ""} · Graph · [0/${total}] routes`);
+			}
 		};
 		const onArtifact = async (artifact) => {
 			routeProgress?.message(`${workerCount} worker${workerCount > 1 ? "s" : ""} · Graph · Writing ${artifact.route.method} ${artifact.route.path}`);
@@ -5919,16 +5922,16 @@ async function generateGraphHandler(cwd, routeArgument, options) {
 		routeProgress?.stop("API-to-backend graph generated");
 		progress$2.finish("API-to-backend graph generated");
 		const backendPaths = artifacts.reduce((total, artifact) => total + artifact.backend_paths.length, 0);
-		note([
+		atlasLogger.note([
 			`Output directory: ${outputDir}`,
 			`Route documents: ${files.length}`,
 			`Backend paths: ${backendPaths}`,
 			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null
 		].filter(Boolean).join("\n"), "Artifacts");
-		outro("Code source graph generation completed");
+		atlasLogger.outro("Code source graph generation completed");
 	} catch (error) {
 		progress$2.fail("Graph generation failed");
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exitCode = 1;
 	}
 }
@@ -5996,18 +5999,18 @@ async function generateTestHandler(cwd) {
 		catalogues.set(expectation.route, await buildCatalogue(documents));
 	}
 	const results = validateCoverage(coverage, catalogues);
-	log.message(results.map((result) => `${result.passed ? "✓" : "✗"} ${result.route}: ${formatPercentage(result.actual)} (minimum ${formatPercentage(result.expected)})`).join("\n"));
+	atlasLogger.info(results.map((result) => `${result.passed ? "✓" : "✗"} ${result.route}: ${formatPercentage(result.actual)} (minimum ${formatPercentage(result.expected)})`).join("\n"));
 	if (results.some((result) => !result.passed)) throw new Error(formatCoverageFailure(results));
 }
 var generateTest_default = (program) => void program.command("generate:test").description("Generate configured routes and verify their resolved-field coverage does not regress").action(async () => {
-	intro("Datasource catalogue generation regression check");
+	atlasLogger.intro("Datasource catalogue generation regression check");
 	const { cwd, test } = getUserConfig();
 	try {
 		await generateTestHandler(cwd);
-		note(`Routes checked: ${test.coverage.length}`, "Coverage");
-		outro("Datasource catalogue generation regression check completed");
+		atlasLogger.note(`Routes checked: ${test.coverage.length}`, "Coverage");
+		atlasLogger.outro("Datasource catalogue generation regression check completed");
 	} catch (error) {
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 });
@@ -23464,7 +23467,7 @@ function parseWorkerCount(value) {
 	return workers;
 }
 var infer_default = (program) => void program.command("infer").argument("[route-or-directory]", "Route selector (GET /v1/offers) or catalogue directory").option("-i, --input <directory>", "Directory containing generated route YAML documents", ".tmp/datasource-catalogue").option("-o, --output <directory>", "Output directory; defaults to updating the input directory").option("--model <name>", "AI model name").option("--ai-url <url>", "AI base URL").option("--min-confidence <number>", "Minimum confidence required to accept an ai/sdk mapping", parseConfidence).option("--timeout <milliseconds>", "Maximum duration of one route-level ai/sdk request", (value) => parsePositiveNumber(value)).option("-w, --workers <count>", "Maximum number of concurrent route inference jobs (max 10)", parseWorkerCount).description("Use AI to review unresolved mappings in generated route YAML documents").action(async (routeOrDirectory, options) => {
-	intro("Datasource catalogue inference");
+	atlasLogger.intro("Datasource catalogue inference");
 	const config = getUserConfig();
 	const inference = config.inference;
 	const resolvedOptions = {
@@ -23498,26 +23501,28 @@ var infer_default = (program) => void program.command("infer").argument("[route-
 				const w = resolvedOptions.workers;
 				if (!inferenceProgress) {
 					progress$1.finish("Route artifacts loaded");
-					inferenceProgress = progress({
-						style: "heavy",
-						max: total,
-						size: 40
-					});
-					inferenceProgress.start(`${w} worker${w > 1 ? "s" : ""} · Infer · [0/${total}] routes`);
+					if (!atlasLogger.isCi) {
+						inferenceProgress = progress({
+							style: "heavy",
+							max: total,
+							size: 40
+						});
+						inferenceProgress.start(`${w} worker${w > 1 ? "s" : ""} · Infer · [0/${total}] routes`);
+					}
 				}
 				const label = `${w} worker${w > 1 ? "s" : ""} · Infer · [${completedRoutes}/${total}] routes · ${route.method} ${route.path} [${phase}]`;
 				if (completed) {
 					completedRoutes += 1;
-					inferenceProgress.advance(1, label.replace(`[${completedRoutes - 1}/${total}]`, `[${completedRoutes}/${total}]`));
+					inferenceProgress?.advance(1, label.replace(`[${completedRoutes - 1}/${total}]`, `[${completedRoutes}/${total}]`));
 					return;
 				}
-				inferenceProgress.message(label);
+				inferenceProgress?.message(label);
 			}
 		}));
 		inferenceProgress?.stop(`Inference completed: ${completedRoutes} route${completedRoutes > 1 ? "s" : ""} · ${resolvedOptions.workers} worker${resolvedOptions.workers > 1 ? "s" : ""}`);
 		progress$1.finish("Inferrence mapping review completed");
 		const rejectionSummary = Object.entries(result.rejectionReasons).filter(([, count]) => count > 0).map(([reason, count]) => `${reason}=${count}`).join(", ");
-		note([
+		atlasLogger.note([
 			`Input directory: ${result.inputPath}`,
 			`Output directory: ${result.outputPath}`,
 			routeSelector ? `Route selector: ${routeSelector.method} ${routeSelector.path}` : null,
@@ -23530,10 +23535,10 @@ var infer_default = (program) => void program.command("infer").argument("[route-
 			`Mappings inferred: ${result.inferred}`,
 			`Needs review remaining in scope: ${result.remainingInScope}`
 		].filter(Boolean).join("\n"), "Inference");
-		outro("Datasource catalogue inference completed");
+		atlasLogger.outro("Datasource catalogue inference completed");
 	} catch (error) {
 		progress$1.fail("AI mapping review failed");
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 });
@@ -23584,7 +23589,7 @@ export default defineConfig({
 var init_default = (program, datasourceCommand) => void program.command("init").option("--force", "Overwrite an existing atlas.config.ts", false).description("Create an atlas.config.ts in the target API project").action(async (options) => {
 	const configPath = path.resolve(datasourceCommand.opts().config ?? CONFIG_FILE_NAME);
 	const configDirectory = path.dirname(configPath);
-	intro("Initialize datasource configuration");
+	atlasLogger.intro("Initialize datasource configuration");
 	try {
 		await fsPromises.mkdir(configDirectory, { recursive: true });
 		if (!options.force) {
@@ -23598,9 +23603,9 @@ var init_default = (program, datasourceCommand) => void program.command("init").
 			if (exists) throw new Error(`${configPath} already exists. Use --force to overwrite it.`);
 		}
 		await fsPromises.writeFile(configPath, configTemplate, "utf8");
-		outro(`Created ${configPath}`);
+		atlasLogger.outro(`Created ${configPath}`);
 	} catch (error) {
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exitCode = 1;
 	}
 });
@@ -23672,7 +23677,7 @@ function formatNeedsReviewTable(rows) {
 	].join("\n");
 }
 var needsReview_default = (program) => void program.command("needs-review").argument("[catalogue-directory]", "Directory containing generated route YAML documents", ".tmp/datasource-catalogue").addOption(new Option("--sort <metric>", "Sort candidates by review count or percentage").choices(["count", "percentage"]).default("count")).option("--limit <number>", "Maximum number of candidate routes to display", (value) => parsePositiveInteger(value)).description("Display needs_review metrics grouped by route").action(async (catalogueDirectory, options) => {
-	intro("Datasource catalogue needs review report");
+	atlasLogger.intro("Datasource catalogue needs review report");
 	const { cwd } = getUserConfig();
 	const progress = taskProgressService.createStepProgress();
 	try {
@@ -23687,10 +23692,10 @@ var needsReview_default = (program) => void program.command("needs-review").argu
 			limit: options.limit
 		}));
 		if (report.rows.length) {
-			log.info("Candidate routes");
-			log.message(formatNeedsReviewTable(report.rows));
-		} else log.info("No route requires review.");
-		note([
+			atlasLogger.info("Candidate routes");
+			atlasLogger.info(formatNeedsReviewTable(report.rows));
+		} else atlasLogger.info("No route requires review.");
+		atlasLogger.note([
 			`Input directory: ${report.inputPath}`,
 			`Route documents: ${report.files.length}`,
 			`Candidate routes: ${report.candidateRoutes}/${report.totalRoutes}`,
@@ -23699,10 +23704,10 @@ var needsReview_default = (program) => void program.command("needs-review").argu
 			`Needs review percentage: ${formatPercentage(report.needsReviewPercentage)}`,
 			options.limit ? `Rows displayed: ${report.rows.length}/${report.candidateRoutes}` : null
 		].filter(Boolean).join("\n"), "Summary");
-		outro("Datasource catalogue needs review report completed");
+		atlasLogger.outro("Datasource catalogue needs review report completed");
 	} catch (error) {
 		progress.fail("Needs review report failed");
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 });
@@ -23857,16 +23862,16 @@ async function reportChangedHandler(cwd, options) {
 	const reportPath = path.resolve(cwd, options.report ?? path.join(config.outputDir, "changed-routes-report.md"));
 	await fsPromises.mkdir(path.dirname(reportPath), { recursive: true });
 	await fsPromises.writeFile(reportPath, `${report}\n`, "utf8");
-	note(report, "Datasource mapping report");
+	atlasLogger.note(report, "Datasource mapping report");
 }
 var reportChanged_default = (program) => void program.command("report:changed").requiredOption("--changed-files <file>", "Newline-delimited list of changed repository files").option("-o, --output <directory>", "Directory containing generated graph artifacts, overriding outputDir").option("--report <file>", "Markdown report output path; defaults to outputDir/changed-routes-report.md").description("Report deterministic mapping coverage for routes impacted by changed files").action(async (options) => {
-	intro("Datasource changed-route report");
+	atlasLogger.intro("Datasource changed-route report");
 	const { cwd } = getUserConfig();
 	try {
 		await reportChangedHandler(cwd, options);
-		outro("Datasource changed-route report completed");
+		atlasLogger.outro("Datasource changed-route report completed");
 	} catch (error) {
-		cancel(error instanceof Error ? error.message : String(error));
+		atlasLogger.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
 });