@cmflow/atlas 3.4.0-beta.5 → 3.4.0-beta.7

package/README.md

@@ -50,10 +50,12 @@ The configuration imports `defineConfig` from Atlas:
 import { defineConfig } from "@cmflow/atlas";
 
 export default defineConfig({
-  backends: ["ICC", "CMS", "CMS_B2C"],
   openapiUrl: "https://api.example.com/openapi.json",
   openapiTimeoutMs: 60_000,
-  directusUrl: "https://cms.api.clubmed"
+  directusUrl: "https://cms.api.clubmed",
+  analysis: {
+    backends: ["ICC", "CMS", "CMS_B2C"]
+  }
 });
 ```
 
@@ -117,7 +119,7 @@ Generate the topology first, then the route catalogue:
 
 ```bash
 atlas --project-root /path/to/api generate:graph
-atlas --project-root /path/to/api generate:catalogue --output .tmp/datasource-catalogue
+atlas --project-root /path/to/api generate:catalog --output .tmp/datasource-catalogue
 ```
 
 Each route produces a YAML document and a `.graph.yaml` topology artifact. The catalogue requires a valid graph and leaves ambiguous fields marked `needs_review`.
@@ -150,7 +152,7 @@ Without `--write`, the command performs a dry run. Use `clean-orphans` to inspec
 ```text
 atlas init                         Create atlas.config.ts
 atlas generate:graph               Trace API routes to backends
-atlas generate:catalogue [route]   Generate route review documents
+atlas generate:catalog [route]     Generate route review documents
 atlas generate:test                Check configured coverage baselines
 atlas needs-review                 Rank unresolved routes
 atlas infer [route|directory]      Optionally enrich unresolved mappings
@@ -161,7 +163,7 @@ atlas report:changed               Report coverage for changed routes
 
 ## CI
 
-The recommended static CI flow is `generate:graph`, `generate:catalogue`, then `push`. Do not run optional inference in CI. Supply `DIRECTUS_URL` and `DIRECTUS_TOKEN` through the CI secret context; skip the push if either value is absent.
+The recommended static CI flow is `generate:graph`, `generate:catalog`, then `push`. Do not run optional inference in CI. Supply `DIRECTUS_URL` and `DIRECTUS_TOKEN` through the CI secret context; skip the push if either value is absent.
 
 ## Development
 

package/dist/bin/atlas.mjs

@@ -1,156 +1,23 @@
 #!/usr/bin/env node
+import { a as isKnownBackendType, c as taskProgressService, d as setUserConfig, i as inferBackendNameFromFile, l as getUserConfig, n as generateBackendTopologyArtifactsInWorkers, o as filterAnalysisFiles, r as resolveModulePath, s as shouldKeepAnalysisFile, u as loadAtlasConfig } from "../routeBackendTopologyService-D_aIIBbX.mjs";
 import { Command, InvalidArgumentError, Option } from "commander";
 import path from "node:path";
-import fs from "node:fs";
-import { pathToFileURL } from "node:url";
 import { Node, Project, SyntaxKind } from "ts-morph";
-import { cancel, intro, log, note, outro, progress, spinner } from "@clack/prompts";
-import fs$1 from "node:fs/promises";
+import { cancel, intro, log, note, outro, progress } from "@clack/prompts";
+import fs from "node:fs/promises";
 import { createDirectus, createItem, deleteItem, readItems, rest, staticToken, updateItem } from "@directus/sdk";
-import { AsyncLocalStorage } from "node:async_hooks";
 import { globby } from "globby";
-import { minimatch } from "minimatch";
 import { createHash } from "node:crypto";
 import { parse, stringify } from "yaml";
-import { Worker } from "node:worker_threads";
 import { NoObjectGeneratedError, Output, generateText } from "ai";
 import { z } from "zod";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-//#region src/utils/config.ts
-let _config;
-function setUserConfig(config) {
-	_config = config;
-}
-function getUserConfig() {
-	if (!_config) throw new Error("Atlas config not loaded. Run Atlas from a directory containing atlas.config.ts or pass --config.");
-	return _config;
-}
-function getTsconfigAliases(repoRoot) {
-	const tsconfigPath = path.join(repoRoot, "tsconfig.json");
-	if (!fs.existsSync(tsconfigPath)) return {};
-	const paths = new Project({
-		tsConfigFilePath: tsconfigPath,
-		skipAddingFilesFromTsConfig: true
-	}).getCompilerOptions().paths ?? {};
-	return Object.fromEntries(Object.entries(paths).flatMap(([alias, targets]) => {
-		const target = targets?.[0];
-		if (!target) return [];
-		return [[alias.replace(/\/\*$/, ""), target.replace(/^\.\//, "").replace(/\/\*$/, "")]];
-	}));
-}
-async function loadAtlasConfig(configPath, projectRoot) {
-	const filePath = path.resolve(configPath);
-	try {
-		let mod;
-		if (filePath.endsWith(".ts")) {
-			const { tsImport } = await import("tsx/esm/api");
-			mod = await tsImport(filePath, import.meta.url);
-		} else mod = await import(pathToFileURL(filePath).href);
-		const config = mod.default ?? mod;
-		const repoRoot = projectRoot || config.repoRoot || process.cwd();
-		return {
-			...config,
-			repoRoot,
-			cwd: repoRoot,
-			resolver: { alias: {
-				...getTsconfigAliases(repoRoot),
-				...config.resolver?.alias
-			} }
-		};
-	} catch (error) {
-		throw new Error(`Unable to load Atlas configuration at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-//#endregion
-//#region src/services/taskProgressService.ts
-function formatDuration(durationMs) {
-	if (durationMs < 1e3) return `${durationMs}ms`;
-	return `${(durationMs / 1e3).toFixed(1)}s`;
-}
-var TaskProgressService = class {
-	#storage = new AsyncLocalStorage();
-	attach(sink, task) {
-		return this.#storage.run(sink, task);
-	}
-	log(message) {
-		this.#storage.getStore()?.log(message);
-	}
-	report(message) {
-		const sink = this.#storage.getStore();
-		(sink?.report || sink?.log)?.(message);
-	}
-	createStepProgress(classify = (message) => ({
-		id: message,
-		title: message
-	})) {
-		const progress = spinner();
-		let active;
-		const finishActive = (label) => {
-			if (!active) return;
-			const duration = formatDuration(Date.now() - active.startedAt);
-			progress.stop(`${label || active.completedTitle || `${active.title} completed`} (${duration})`);
-			active = void 0;
-		};
-		const start = (step) => {
-			if (active?.id === step.id) {
-				progress.message(step.detail ? `${step.title}: ${step.detail}` : step.title);
-				return;
-			}
-			finishActive();
-			active = {
-				id: step.id,
-				title: step.title,
-				completedTitle: step.completedTitle,
-				startedAt: Date.now()
-			};
-			progress.start(step.detail ? `${step.title}: ${step.detail}` : step.title);
-		};
-		const execute = (task) => this.attach({
-			log: (message) => progress.message(active ? `${active.title}: ${message}` : message),
-			report: (message) => start(classify(message))
-		}, task);
-		return {
-			report(message) {
-				start(classify(message));
-			},
-			start,
-			execute,
-			run: async (step, task) => {
-				start(step);
-				await new Promise((resolve) => setImmediate(resolve));
-				const result = await execute(task);
-				finishActive();
-				return result;
-			},
-			finish(label) {
-				finishActive(label);
-			},
-			fail(label) {
-				if (!active) return;
-				const duration = formatDuration(Date.now() - active.startedAt);
-				progress.stop(`${label} (${duration})`);
-				active = void 0;
-			}
-		};
-	}
-};
-const taskProgressService = new TaskProgressService();
-//#endregion
 //#region src/utils/catalogueStats.ts
 function calculateNeedsReviewPercentage(inputProperties, outputProperties, needsReview) {
 	const properties = inputProperties + outputProperties;
 	return properties ? Number((needsReview / properties * 100).toFixed(2)) : 0;
 }
 //#endregion
-//#region src/services/analysisFileService.ts
-function shouldKeepAnalysisFile(filePath) {
-	const normalizedProjectPath = filePath.replaceAll(path.sep, "/").replace(/^.*?(app\/)/, "app/");
-	return !getUserConfig().analysis.excluded.some((pattern) => minimatch(normalizedProjectPath, pattern, { dot: true }));
-}
-function filterAnalysisFiles(filePaths) {
-	return filePaths.filter(shouldKeepAnalysisFile);
-}
-//#endregion
 //#region src/services/useCaseAnalysisService.ts
 function normalizeCodeText(value) {
 	return value.replace(/\s+/g, " ").replace(/;$/, "").trim();
@@ -391,25 +258,6 @@ function extractOpenApiOutputProperties(operation, swagger) {
 	return [...map.values()];
 }
 //#endregion
-//#region src/services/backendTypeService.ts
-function getBackendTypes() {
-	return Object.fromEntries(getUserConfig().backends.map((backend) => [backend, backend]));
-}
-function isKnownBackendType(value) {
-	return Object.hasOwn(getBackendTypes(), value);
-}
-//#endregion
-//#region src/services/backendSourceService.ts
-function inferBackendNameFromFile(sourceFile) {
-	const declaredType = sourceFile.getFullText().match(/BackendTypes\.([A-Z0-9_]+)/)?.[1];
-	if (declaredType) return isKnownBackendType(declaredType) ? declaredType : null;
-	const parts = sourceFile.getFilePath().split(path.sep);
-	const backIndex = parts.lastIndexOf("back");
-	const infrastructureIndex = parts.lastIndexOf("_infra");
-	const candidate = backIndex >= 0 ? parts[backIndex + 1] : infrastructureIndex >= 0 ? parts[infrastructureIndex + 2] : void 0;
-	return candidate && isKnownBackendType(candidate.toUpperCase()) ? candidate.toUpperCase() : null;
-}
-//#endregion
 //#region src/services/backendRouteExtractionService.ts
 function looksLikeBackendRoute(value) {
 	return value.startsWith("/") || /^https?:\/\//.test(value) || /^graphql$/i.test(value);
@@ -460,51 +308,6 @@ function normalizeDescription(description) {
 	return description?.trim() || "";
 }
 //#endregion
-//#region src/utils/resolveAliasPath.ts
-function resolveAliasPath(moduleSpecifier, aliases, rootPath) {
-	for (const [alias, target] of Object.entries(aliases)) {
-		if (moduleSpecifier !== alias && !moduleSpecifier.startsWith(`${alias}/`)) continue;
-		const modulePath = moduleSpecifier.slice(alias.length).replace(/^\//, "");
-		return path.join(rootPath, target, modulePath);
-	}
-	return null;
-}
-//#endregion
-//#region src/utils/tryResolveWithExtensions.ts
-function tryResolveWithExtensions(basePath) {
-	const ext = path.extname(basePath);
-	const withoutExt = ext ? basePath.slice(0, -ext.length) : basePath;
-	const candidates = [
-		basePath,
-		ext === ".js" ? `${withoutExt}.ts` : null,
-		ext === ".ts" ? `${withoutExt}.js` : null,
-		ext === ".mjs" ? `${withoutExt}.mts` : null,
-		ext === ".mts" ? `${withoutExt}.mjs` : null,
-		`${basePath}.ts`,
-		`${basePath}.js`,
-		`${basePath}.mts`,
-		`${basePath}.mjs`,
-		path.join(withoutExt, "index.ts"),
-		path.join(withoutExt, "index.js"),
-		path.join(basePath, "index.ts"),
-		path.join(basePath, "index.js")
-	].filter((candidate) => Boolean(candidate));
-	for (const candidate of candidates) try {
-		const normalized = path.normalize(candidate);
-		if (fs.existsSync(normalized)) return normalized;
-	} catch {
-		continue;
-	}
-	return null;
-}
-//#endregion
-//#region src/utils/resolveModulePath.ts
-function resolveModulePath(sourceFilePath, moduleSpecifier, aliases, rootPath) {
-	if (moduleSpecifier.startsWith(".")) return tryResolveWithExtensions(path.resolve(path.dirname(sourceFilePath), moduleSpecifier));
-	const aliased = resolveAliasPath(moduleSpecifier, aliases, rootPath);
-	return aliased ? tryResolveWithExtensions(aliased) : null;
-}
-//#endregion
 //#region src/utils/dedupeByKey.ts
 function dedupeByKey(items, keyFn) {
 	const map = /* @__PURE__ */ new Map();
@@ -1446,11 +1249,12 @@ async function analyzeCodebaseRouteContracts(params) {
 		}) : void 0;
 		if (routeAnalysisScope && !topologyScope) continue;
 		taskProgressService.log(topologyScope ? `${routeLabel} ... Loading dependencies from backend graph` : `${routeLabel} ... Collecting dependencies`);
-		const analysisFiles = filterAnalysisFiles(dedupeByKey(await (topologyScope ? topologyScope.analysisFiles : handler.handlerFile ? dependencyFilesByHandler.get(handler.handlerFile) || (() => {
+		const dependencyFiles = topologyScope ? topologyScope.analysisFiles : handler.handlerFile ? dependencyFilesByHandler.get(handler.handlerFile) || (() => {
 			const files = collectDependencyFiles(project, handler.handlerFile, routeLabel, resolveCachedModulePath);
 			dependencyFilesByHandler.set(handler.handlerFile, files);
 			return files;
-		})() : [routeDeclaration.file]), (value) => value));
+		})() : [routeDeclaration.file];
+		const analysisFiles = filterAnalysisFiles(dedupeByKey(await dependencyFiles, (value) => value));
 		taskProgressService.log(`${routeLabel} ... Extracting mappings from ${analysisFiles.length} relevant files`);
 		await yieldToEventLoop();
 		const backendSourceFiles = analysisFiles.filter((file) => file.includes(`${path.sep}app${path.sep}_infra${path.sep}back${path.sep}`)).map((file) => project.getSourceFile(file) || project.addSourceFileAtPath(file)).filter((sourceFile) => {
@@ -2359,7 +2163,7 @@ async function pushCatalogueToDirectus(catalogue, options) {
 			}
 		}
 	}
-	if (options.outputPath) await fs$1.appendFile(options.outputPath, "", "utf8");
+	if (options.outputPath) await fs.appendFile(options.outputPath, "", "utf8");
 	const removedOrphanedLinks = await cleanupOrphanedPropertyLinks(client);
 	taskProgressService.report("Finalizing Directus synchronization");
 	if (warnings.size) {
@@ -2555,12 +2359,12 @@ async function writeRouteReviewDocument(catalogue, outputDir, repoRoot, routeKey
 	if (!route) throw new Error(`Unable to write review document for unknown route key ${routeKey}`);
 	const document = relativizeRouteReviewDocument(buildRouteReviewDocument(catalogue, route.key), repoRoot);
 	const filePath = path.join(outputDir, buildRouteReviewRelativePath(route.method, route.path));
-	await fs$1.mkdir(path.dirname(filePath), { recursive: true });
-	await fs$1.writeFile(filePath, `${stringify(document)}\n`, "utf8");
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${stringify(document)}\n`, "utf8");
 	return filePath;
 }
 async function writeRouteReviewDocuments(catalogue, outputDir, repoRoot) {
-	await fs$1.mkdir(outputDir, { recursive: true });
+	await fs.mkdir(outputDir, { recursive: true });
 	for (const [index, route] of catalogue.routes.entries()) {
 		taskProgressService.log(`[${index + 1}/${catalogue.routes.length}] - ${route.method} ${route.path} ...`);
 		await writeRouteReviewDocument(catalogue, outputDir, repoRoot, route.key);
@@ -2568,8 +2372,8 @@ async function writeRouteReviewDocuments(catalogue, outputDir, repoRoot) {
 	return outputDir;
 }
 async function prepareCatalogueOutputDirectory(outputDir) {
-	await fs$1.mkdir(outputDir, { recursive: true });
-	await Promise.all(["catalogue.yaml", "catalogue.yml"].map((fileName) => fs$1.rm(path.join(outputDir, fileName), { force: true })));
+	await fs.mkdir(outputDir, { recursive: true });
+	await Promise.all(["catalogue.yaml", "catalogue.yml"].map((fileName) => fs.rm(path.join(outputDir, fileName), { force: true })));
 }
 async function writeCatalogueArtifacts(catalogue, outputDir, repoRoot = process.cwd()) {
 	await prepareCatalogueOutputDirectory(outputDir);
@@ -2747,7 +2551,7 @@ async function readCatalogueFromDirectory(inputDir) {
 	if (!files.length) throw new Error(`No route YAML documents found in ${inputDir}`);
 	return {
 		catalogue: mergeRouteReviewDocuments(await Promise.all(files.sort().map(async (file) => {
-			const parsed = parse(await fs$1.readFile(file, "utf8"));
+			const parsed = parse(await fs.readFile(file, "utf8"));
 			if (parsed?.schema_version !== 1 || !parsed?.route?.method || !parsed?.route?.path) throw new Error(`Invalid route YAML document: ${file}`);
 			return parsed;
 		}))),
@@ -2941,8 +2745,8 @@ function buildBackendTopologyRelativePath(method, routePath) {
 }
 async function writeBackendTopologyArtifact(artifact, outputDir) {
 	const filePath = path.join(outputDir, buildBackendTopologyRelativePath(artifact.route.method, artifact.route.path));
-	await fs$1.mkdir(path.dirname(filePath), { recursive: true });
-	await fs$1.writeFile(filePath, `${stringify(artifact, { aliasDuplicateObjects: false })}\n`, "utf8");
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${stringify(artifact, { aliasDuplicateObjects: false })}\n`, "utf8");
 	return filePath;
 }
 function isRecord(value) {
@@ -2961,7 +2765,7 @@ async function loadBackendTopologyAnalysisScope(outputDir, cwd, method, routePat
 	const filePath = path.join(outputDir, buildBackendTopologyRelativePath(method, routePath));
 	let content;
 	try {
-		content = await fs$1.readFile(filePath, "utf8");
+		content = await fs.readFile(filePath, "utf8");
 	} catch (error) {
 		if (isRecord(error) && error.code === "ENOENT") throw new Error(`Backend graph artifact not found for ${method} ${routePath}: ${filePath}. Run generate:graph first.`);
 		throw error;
@@ -2982,7 +2786,7 @@ async function loadBackendTopologyAnalysisScope(outputDir, cwd, method, routePat
 	const missingFiles = [];
 	await Promise.all(analysisFiles.map(async (analysisFile) => {
 		try {
-			await fs$1.access(analysisFile);
+			await fs.access(analysisFile);
 		} catch {
 			missingFiles.push(path.relative(cwd, analysisFile));
 		}
@@ -3082,7 +2886,7 @@ async function generateHandler(cwd, routeArgument, options) {
 		process.exit(1);
 	}
 }
-var generate_default = (program) => void program.command("generate:catalogue").argument("[route]", "Route selector in the format \"GET /v1/products\"").option("-o, --output <directory>", "Directory where catalogue artifacts are generated", ".tmp/datasource-catalogue").option("--openapi-url <url>", "OpenAPI document URL").option("--profile", "Display elapsed time by generation stage").description("Analyze the codebase and generate one YAML review document per route").action((routeArgument, options) => {
+var generate_default = (program) => void program.command("generate:catalog").argument("[route]", "Route selector in the format \"GET /v1/products\"").option("-o, --output <directory>", "Directory where catalogue artifacts are generated", ".tmp/datasource-catalogue").option("--openapi-url <url>", "OpenAPI document URL").option("--profile", "Display elapsed time by generation stage").description("Analyze the codebase and generate one YAML review document per route").action((routeArgument, options) => {
 	const config = getUserConfig();
 	return generateHandler(config.cwd, routeArgument, {
 		...options,
@@ -3090,104 +2894,6 @@ var generate_default = (program) => void program.command("generate:catalogue").a
 	});
 });
 //#endregion
-//#region src/services/routeBackendTopologyService.ts
-function stringProperty(object, name) {
-	const property = object.getProperty(name);
-	if (!property || !Node.isPropertyAssignment(property)) return void 0;
-	const initializer = property.getInitializer();
-	return initializer && (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) ? initializer.getLiteralValue() : void 0;
-}
-function handlerProperty(object) {
-	const property = object.getProperty("handler");
-	if (!property || !Node.isPropertyAssignment(property)) return void 0;
-	const initializer = property.getInitializer();
-	return initializer && (Node.isIdentifier(initializer) || Node.isPropertyAccessExpression(initializer)) ? initializer.getText() : void 0;
-}
-function extractRouteDeclarations(sourceFile) {
-	const initializer = sourceFile.getVariableDeclaration("routes")?.getInitializer();
-	let expression = initializer;
-	if (initializer && (Node.isAsExpression(initializer) || Node.isSatisfiesExpression(initializer))) expression = initializer.getExpression();
-	if (!expression || !Node.isArrayLiteralExpression(expression)) return [];
-	return expression.getElements().flatMap((element) => {
-		if (!Node.isObjectLiteralExpression(element)) return [];
-		const method = stringProperty(element, "method");
-		const routePath = stringProperty(element, "path");
-		const handlerRef = handlerProperty(element);
-		return method && routePath && handlerRef ? [{
-			method: method.toUpperCase(),
-			path: routePath,
-			sourceFile,
-			handlerRef
-		}] : [];
-	});
-}
-async function discoverBackendTopologyRouteSelectors(cwd) {
-	const project = new Project({
-		skipAddingFilesFromTsConfig: true,
-		compilerOptions: {
-			allowJs: true,
-			checkJs: false
-		}
-	});
-	return (await globby(["app/_api/**/routes.@(js|ts)", "app/legacy/**/routes.@(js|ts)"], {
-		cwd,
-		absolute: true
-	})).flatMap((routeFile) => extractRouteDeclarations(project.addSourceFileAtPath(routeFile))).map((route) => ({
-		method: route.method,
-		path: route.path
-	}));
-}
-async function generateBackendTopologyArtifactsInWorkers(params) {
-	const selectors = params.routeSelector ? [params.routeSelector] : await discoverBackendTopologyRouteSelectors(params.cwd);
-	params.onRoutesDiscovered?.(selectors.length);
-	const workerCount = Math.min(params.workers || 2, selectors.length);
-	const chunks = Array.from({ length: workerCount }, () => []);
-	selectors.forEach((selector, index) => chunks[index % workerCount].push(selector));
-	const artifacts = [];
-	let completed = 0;
-	let writeQueue = Promise.resolve();
-	const workers = [];
-	try {
-		await Promise.all(chunks.map((routeSelectors) => new Promise((resolve, reject) => {
-			const worker = new Worker(new URL("./routeBackendTopologyWorker.ts", import.meta.url), {
-				workerData: {
-					cwd: params.cwd,
-					routeSelectors
-				},
-				execArgv: process.execArgv
-			});
-			workers.push(worker);
-			worker.on("message", (message) => {
-				if (message.type === "error") {
-					reject(new Error(message.message));
-					return;
-				}
-				writeQueue = writeQueue.then(async () => {
-					if (message.type === "artifact") {
-						await params.onArtifact(message.artifact);
-						artifacts.push(message.artifact);
-						return;
-					}
-					completed += 1;
-					params.onRouteProgress?.({
-						current: completed,
-						total: selectors.length,
-						route: message.route,
-						stage: "completed"
-					});
-				}).catch(reject);
-			});
-			worker.once("error", reject);
-			worker.once("exit", (code) => code === 0 ? resolve() : reject(/* @__PURE__ */ new Error(`Topology worker exited with code ${code}`)));
-		})));
-		await writeQueue;
-		return artifacts;
-	} catch (error) {
-		await Promise.all(workers.map((worker) => worker.terminate().catch(() => void 0)));
-		throw error;
-	}
-}
-//#endregion
 //#region src/commands/generateGraph.ts
 function parseWorkerCount$1(value) {
 	const workers = Number(value);
@@ -3442,7 +3148,7 @@ async function readSourceExcerpts(document) {
 	const excerpts = [];
 	let totalCharacters = 0;
 	for (const location of uniqueLocations) try {
-		const lines = (await fs$1.readFile(location.sourceFile, "utf8")).split("\n");
+		const lines = (await fs.readFile(location.sourceFile, "utf8")).split("\n");
 		const startLine = Math.max(1, location.line - EXCERPT_RADIUS);
 		const endLine = Math.min(lines.length, location.line + EXCERPT_RADIUS);
 		const code = lines.slice(startLine - 1, endLine).map((line, index) => `${String(startLine + index).padStart(5)} | ${line}`).join("\n");
@@ -4169,7 +3875,6 @@ const configTemplate = `import { defineConfig } from "@cmflow/atlas";
 
 export default defineConfig({
   repoRoot: process.cwd(),
-  backends: [],
   openapiUrl: "https://api.example.com/openapi.json",
   openapiTimeoutMs: 60_000,
   directusUrl: "https://cms.api.clubmed",
@@ -4181,6 +3886,7 @@ export default defineConfig({
     workers: 2
   },
   analysis: {
+    backends: [],
     excluded: [],
     transversalInputs: [],
     ignoredOutputs: [],
@@ -4208,18 +3914,18 @@ var init_default = (program, datasourceCommand) => void program.command("init").
 	const configDirectory = path.dirname(configPath);
 	intro("Initialize datasource configuration");
 	try {
-		await fs$1.mkdir(configDirectory, { recursive: true });
+		await fs.mkdir(configDirectory, { recursive: true });
 		if (!options.force) {
 			let exists = false;
 			try {
-				await fs$1.access(configPath);
+				await fs.access(configPath);
 				exists = true;
 			} catch (error) {
 				if (error.code !== "ENOENT") throw error;
 			}
 			if (exists) throw new Error(`${configPath} already exists. Use --force to overwrite it.`);
 		}
-		await fs$1.writeFile(configPath, configTemplate, "utf8");
+		await fs.writeFile(configPath, configTemplate, "utf8");
 		outro(`Created ${configPath}`);
 	} catch (error) {
 		cancel(error instanceof Error ? error.message : String(error));
@@ -4352,7 +4058,7 @@ function collectImpactedRoutes(params) {
 	return params.graphs.filter((graph) => graph.analysisFiles.some((analysisFile) => changedFiles.has(normalizeFilePath(analysisFile)))).sort((left, right) => `${left.method} ${left.path}`.localeCompare(`${right.method} ${right.path}`));
 }
 async function readChangedFiles(filePath) {
-	return (await fs$1.readFile(filePath, "utf8")).split(/\r?\n/).map((line) => normalizeFilePath(line.trim())).filter(Boolean);
+	return (await fs.readFile(filePath, "utf8")).split(/\r?\n/).map((line) => normalizeFilePath(line.trim())).filter(Boolean);
 }
 async function readRouteGraphs(outputDirectory) {
 	const graphFiles = await globby("**/*.graph.yaml", {
@@ -4360,7 +4066,7 @@ async function readRouteGraphs(outputDirectory) {
 		absolute: true
 	});
 	const graphs = await Promise.all(graphFiles.map(async (graphFile) => {
-		const document = parse(await fs$1.readFile(graphFile, "utf8"));
+		const document = parse(await fs.readFile(graphFile, "utf8"));
 		if (!isGraphDocument(document)) throw new Error(`Invalid graph document: ${graphFile}`);
 		return {
 			method: document.route.method,
@@ -4478,8 +4184,8 @@ async function reportChangedHandler(cwd, options) {
 		routes: coverages
 	});
 	const reportPath = path.resolve(cwd, options.report);
-	await fs$1.mkdir(path.dirname(reportPath), { recursive: true });
-	await fs$1.writeFile(reportPath, `${report}\n`, "utf8");
+	await fs.mkdir(path.dirname(reportPath), { recursive: true });
+	await fs.writeFile(reportPath, `${report}\n`, "utf8");
 	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", ".tmp/datasource-catalogue").option("--report <file>", "Markdown report output path", ".tmp/datasource-catalogue/changed-routes-report.md").description("Report deterministic mapping coverage for routes impacted by changed files").action(async (options) => {
@@ -4499,7 +4205,8 @@ const program = new Command();
 program.version("3.4.0-alpha.1");
 program.name("atlas").description("Manage the API-to-backend mapping catalogue").option("--project-root <path>", "Root directory of the API project to analyze").option("-c, --config <path>", "Path to atlas.config.ts", path.resolve(process.cwd(), "atlas.config.ts")).hook("preAction", async (_thisCommand, actionCommand) => {
 	if (actionCommand.name() === "init") return;
-	setUserConfig(await loadAtlasConfig(program.opts().config, program.opts().projectRoot));
+	const config = await loadAtlasConfig(program.opts().config, program.opts().projectRoot);
+	setUserConfig(config);
 });
 init_default(program, program);
 generate_default(program);

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { r as defineExpressionRule, t as UserConfig } from "./types-DcvdOZ2j.mjs";
+import { r as defineExpressionRule, t as UserConfig } from "./types-3y34Gf8R.mjs";
 //#region src/utils/defineConfig.d.ts
 declare function defineConfig(config: UserConfig): UserConfig;
 //#endregion