@azure-net/cli 4.0.0-1 → 4.1.0

package/bin/azure-net.js

@@ -241,6 +241,14 @@ checkCommand
 		await handler();
 	});
 
+checkCommand
+	.command('provider-graph')
+	.description('Check provider dependency graph for cycles')
+	.action(async () => {
+		const handler = (await import('../src/checks/checkProviderGraph.js')).default;
+		await handler();
+	});
+
 checkCommand
 	.command('domain')
 	.description('Check domain naming and structure rules in all contexts')

package/bin/azure-net.ts

@@ -241,6 +241,14 @@ checkCommand
 		await handler();
 	});
 
+checkCommand
+	.command('provider-graph')
+	.description('Check provider dependency graph for cycles')
+	.action(async () => {
+		const handler = (await import('../src/checks/checkProviderGraph.js')).default;
+		await handler();
+	});
+
 checkCommand
 	.command('domain')
 	.description('Check domain naming and structure rules in all contexts')
@@ -249,6 +257,14 @@ checkCommand
 		await handler();
 	});
 
+checkCommand
+	.command('imports')
+	.description('Check import extensions and import group order in src')
+	.action(async () => {
+		const handler = (await import('../src/checks/checkImports.js')).default;
+		await handler();
+	});
+
 checkCommand
 	.command('layer-boundaries')
 	.description('Check layer boundaries between contexts by aliases')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-net/cli",
-  "version": "4.0.0-1",
+  "version": "4.1.0",
   "type": "module",
   "bin": {
     "azure-net": "bin/azure-net.js"

package/src/checks/checkDomain.ts

@@ -49,6 +49,8 @@ const isEnumsPath = (filePath: string): boolean => {
 
 const isIndexFile = (filePath: string): boolean => path.basename(filePath) === 'index.ts';
 
+const startsWithInterfacePrefix = (filePath: string): boolean => /^I[A-Z]/.test(path.basename(filePath, '.ts'));
+
 const isExportOnlyIndex = (content: string): boolean => {
 	const withoutComments = stripComments(content);
 	const withoutExports = stripExportStatements(withoutComments);
@@ -144,6 +146,14 @@ const collectIssuesForFile = (filePath: string, content: string): DomainIssue[]
 		return issues;
 	}
 
+	if (!isIndexFile(filePath) && startsWithInterfacePrefix(filePath)) {
+		issues.push({
+			file: filePath,
+			line: 1,
+			message: 'Domain file names must not start with "I". Keep "I" only in interface/type names'
+		});
+	}
+
 	const declarations = extractDeclarations(content);
 	if (declarations.length > 5) {
 		issues.push({

package/src/checks/checkImports.ts

@@ -0,0 +1,166 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type ImportIssue = {
+	file: string;
+	line: number;
+	message: string;
+};
+
+type ImportKind = 'value' | 'type' | 'side-effect';
+
+type ImportEntry = {
+	kind: ImportKind;
+	line: number;
+	source: string;
+	raw: string;
+};
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js', '.svelte']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+const IMPORT_DECLARATION_PATTERN = /(^|\n)\s*import\s+(?:[\s\S]*?\s+from\s*)?['"]([^'"]+)['"]\s*;?/g;
+const FORBIDDEN_IMPORT_EXTENSION_PATTERN = /\.(?:ts|js)$/;
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const getRelativePath = (filePath: string): string => toPosixPath(path.relative(process.cwd(), filePath));
+
+const findLineByIndex = (content: string, index: number): number => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+
+const listFiles = async (rootDir: string): Promise<string[]> => {
+	const files: string[] = [];
+	const stack: string[] = [rootDir];
+
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current) continue;
+
+		let entries: import('node:fs').Dirent[] = [];
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) {
+					stack.push(path.join(current, entry.name));
+				}
+				continue;
+			}
+
+			if (!entry.isFile()) continue;
+			const filePath = path.join(current, entry.name);
+			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+
+	return files;
+};
+
+const getImportKind = (raw: string): ImportKind => {
+	const normalized = raw.trim();
+	if (/^import\s+type\b/.test(normalized)) return 'type';
+	if (/^import\s*['"]/.test(normalized)) return 'side-effect';
+	return 'value';
+};
+
+const getKindOrder = (kind: ImportKind): number => {
+	if (kind === 'value') return 0;
+	if (kind === 'type') return 1;
+	return 2;
+};
+
+const extractImports = (content: string): ImportEntry[] => {
+	const imports: ImportEntry[] = [];
+	const regex = new RegExp(IMPORT_DECLARATION_PATTERN.source, 'g');
+	let match: RegExpExecArray | null;
+
+	while ((match = regex.exec(content)) !== null) {
+		const raw = match[0].trim();
+		const source = match[2];
+		if (!source) continue;
+
+		imports.push({
+			kind: getImportKind(raw),
+			line: findLineByIndex(content, match.index + (match[1] === '\n' ? 1 : 0)),
+			source,
+			raw
+		});
+	}
+
+	return imports.sort((a, b) => a.line - b.line);
+};
+
+const hasForbiddenExtension = (source: string): boolean => {
+	const sourceWithoutQuery = source.split('?')[0] ?? source;
+	return FORBIDDEN_IMPORT_EXTENSION_PATTERN.test(sourceWithoutQuery);
+};
+
+const collectIssuesForFile = (filePath: string, content: string): ImportIssue[] => {
+	const issues: ImportIssue[] = [];
+	const imports = extractImports(content);
+	let lastKindOrder = 0;
+
+	for (const importEntry of imports) {
+		if (hasForbiddenExtension(importEntry.source)) {
+			issues.push({
+				file: filePath,
+				line: importEntry.line,
+				message: `Import "${importEntry.source}" must not include .ts/.js extension`
+			});
+		}
+
+		const currentOrder = getKindOrder(importEntry.kind);
+		if (currentOrder < lastKindOrder) {
+			issues.push({
+				file: filePath,
+				line: importEntry.line,
+				message: 'Import order violation: value imports first, then type imports, then side-effect imports'
+			});
+		}
+		lastKindOrder = Math.max(lastKindOrder, currentOrder);
+	}
+
+	return issues;
+};
+
+export default async function checkImports(): Promise<void> {
+	const srcRoot = path.join(process.cwd(), 'src');
+
+	try {
+		await fs.access(srcRoot);
+	} catch {
+		console.error('❌ src folder not found.');
+		process.exitCode = 1;
+		return;
+	}
+
+	const issues: ImportIssue[] = [];
+	const files = await listFiles(srcRoot);
+
+	for (const filePath of files) {
+		const content = await fs.readFile(filePath, 'utf-8');
+		issues.push(...collectIssuesForFile(filePath, content));
+	}
+
+	if (!issues.length) {
+		console.log('✅ Imports check passed: extensions and import groups are valid.');
+		return;
+	}
+
+	console.error('❌ Imports check failed:');
+	for (const issue of issues) {
+		console.error(`• ${getRelativePath(issue.file)}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkInternal.js

@@ -1,5 +1,6 @@
 import checkPresenterNames from './checkPresenterNames.js';
 import checkProviderNames from './checkProviderNames.js';
+import checkProviderGraph from './checkProviderGraph.js';
 import checkDomain from './checkDomain.js';
 import checkLayerBoundaries from './checkLayerBoundaries.js';
 import checkFoldersStructure from './checkFoldersStructure.js';
@@ -7,6 +8,7 @@ import checkFoldersStructure from './checkFoldersStructure.js';
 const tasks = [
 	{ name: 'presenter-names', run: checkPresenterNames },
 	{ name: 'provider-names', run: checkProviderNames },
+	{ name: 'provider-graph', run: checkProviderGraph },
 	{ name: 'domain', run: checkDomain },
 	{ name: 'layer-boundaries', run: checkLayerBoundaries },
 	{ name: 'folders-structure', run: checkFoldersStructure }

package/src/checks/checkInternal.ts

@@ -1,8 +1,10 @@
 import checkPresenterNames from './checkPresenterNames.js';
 import checkProviderNames from './checkProviderNames.js';
+import checkProviderGraph from './checkProviderGraph.js';
 import checkDomain from './checkDomain.js';
 import checkLayerBoundaries from './checkLayerBoundaries.js';
 import checkFoldersStructure from './checkFoldersStructure.js';
+import checkImports from './checkImports.js';
 
 type CheckTask = {
 	name: string;
@@ -12,7 +14,9 @@ type CheckTask = {
 const tasks: CheckTask[] = [
 	{ name: 'presenter-names', run: checkPresenterNames },
 	{ name: 'provider-names', run: checkProviderNames },
+	{ name: 'provider-graph', run: checkProviderGraph },
 	{ name: 'domain', run: checkDomain },
+	{ name: 'imports', run: checkImports },
 	{ name: 'layer-boundaries', run: checkLayerBoundaries },
 	{ name: 'folders-structure', run: checkFoldersStructure }
 ];

package/src/checks/checkLayerBoundaries.ts

@@ -131,18 +131,45 @@ export default async function checkLayerBoundaries(): Promise<void> {
 
 	const issues: BoundaryIssue[] = [];
 
+	const coreRoot = path.join(process.cwd(), 'src', 'core');
+	try {
+		await fs.access(coreRoot);
+		const coreFiles = await listFiles(coreRoot);
+		for (const filePath of coreFiles) {
+			const content = await fs.readFile(filePath, 'utf-8');
+			const imports = extractImports(content);
+
+			for (const entry of imports) {
+				const targetAlias = resolveAliasFromImport(entry.value, knownAliases);
+				if (!targetAlias || targetAlias === coreAlias) continue;
+				if (!aliasToContext.has(targetAlias)) continue;
+
+				const targetContext = aliasToContext.get(targetAlias);
+				issues.push({
+					file: filePath,
+					line: entry.line,
+					message: targetContext
+						? `Layer boundary violation: core cannot import from context "${targetContext.name}" (${targetAlias})`
+						: `Layer boundary violation: core cannot import from "${targetAlias}"`
+				});
+			}
+		}
+	} catch {
+		// Core folder is optional for the check.
+	}
+
 	for (const context of contexts) {
-		const layersRoot = path.join(process.cwd(), 'src', 'app', context.name, 'layers');
+		const contextRoot = path.join(process.cwd(), 'src', 'app', context.name);
 
 		try {
-			await fs.access(layersRoot);
+			await fs.access(contextRoot);
 		} catch {
 			continue;
 		}
 
-		const files = await listFiles(layersRoot);
+		const files = await listFiles(contextRoot);
 		const allowedAliases = new Set<string>([context.alias, coreAlias]);
-		if (sharedAlias) {
+		if (sharedAlias && context.alias !== sharedAlias) {
 			allowedAliases.add(sharedAlias);
 		}
 

package/src/checks/checkProject.js

@@ -33,7 +33,7 @@ export default async function checkProject() {
 		runScript(manager, 'format');
 		await runInternalChecks();
 		runScript(manager, 'lint');
-		runScript(manager, 'typecheck');
+		runScript(manager, 'check');
 		console.log('\n✅ Project checks passed.');
 	} catch (error) {
 		console.error(`\n❌ Project checks failed: ${error instanceof Error ? error.message : String(error)}`);

package/src/checks/checkProject.ts

@@ -36,7 +36,7 @@ export default async function checkProject(): Promise<void> {
 		runScript(manager, 'format');
 		await runInternalChecks();
 		runScript(manager, 'lint');
-		runScript(manager, 'typecheck');
+		runScript(manager, 'check');
 		console.log('\n✅ Project checks passed.');
 	} catch (error) {
 		console.error(`\n❌ Project checks failed: ${error instanceof Error ? error.message : String(error)}`);

package/src/checks/checkProviderGraph.js

@@ -0,0 +1,221 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+
+const toPosixPath = (value) => value.split(path.sep).join('/');
+
+const getLineByIndex = (content, index) => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+
+const listSourceFiles = async (rootDir) => {
+	const files = [];
+	const stack = [rootDir];
+
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current) continue;
+
+		let entries = [];
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) stack.push(path.join(current, entry.name));
+				continue;
+			}
+
+			if (!entry.isFile()) continue;
+			const filePath = path.join(current, entry.name);
+			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+
+	return files;
+};
+
+const findMatchingBracket = (content, startIndex, openChar, closeChar) => {
+	let depth = 0;
+	for (let i = startIndex; i < content.length; i += 1) {
+		const ch = content[i];
+		if (ch === openChar) depth += 1;
+		if (ch === closeChar) {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+};
+
+const extractDependsOn = (configBlock) => {
+	const dependsOnMatch = configBlock.match(/dependsOn\s*:\s*\{([\s\S]*?)\}/m);
+	if (!dependsOnMatch?.[1]) return [];
+
+	const block = dependsOnMatch[1];
+	const deps = new Set();
+	const keyRegex = /([A-Za-z_$][A-Za-z0-9_$]*)\s*:/g;
+	let match;
+	while ((match = keyRegex.exec(block)) !== null) {
+		const key = match[1];
+		if (key) deps.add(key);
+	}
+	return [...deps];
+};
+
+const parseProviderGraphFromFile = (content, filePath) => {
+	const nodes = [];
+	const token = 'createBoundaryProvider(';
+	let fromIndex = 0;
+
+	while (fromIndex < content.length) {
+		const start = content.indexOf(token, fromIndex);
+		if (start === -1) break;
+
+		const openParenIndex = start + token.length - 1;
+		const closeParenIndex = findMatchingBracket(content, openParenIndex, '(', ')');
+		if (closeParenIndex === -1) break;
+
+		const fullCall = content.slice(openParenIndex + 1, closeParenIndex);
+		const idMatch = fullCall.match(/^\s*(['"`])([^'"`]+)\1\s*,/m);
+		const providerName = idMatch?.[2];
+		if (providerName) {
+			const objectStartInCall = fullCall.indexOf('{');
+			if (objectStartInCall !== -1) {
+				const absoluteObjectStart = openParenIndex + 1 + objectStartInCall;
+				const absoluteObjectEnd = findMatchingBracket(content, absoluteObjectStart, '{', '}');
+				const configBlock =
+					absoluteObjectEnd !== -1 ? content.slice(absoluteObjectStart, absoluteObjectEnd + 1) : fullCall.slice(objectStartInCall);
+
+				nodes.push({
+					name: providerName,
+					file: filePath,
+					line: getLineByIndex(content, start),
+					dependsOn: extractDependsOn(configBlock)
+				});
+			} else {
+				nodes.push({
+					name: providerName,
+					file: filePath,
+					line: getLineByIndex(content, start),
+					dependsOn: []
+				});
+			}
+		}
+
+		fromIndex = closeParenIndex + 1;
+	}
+
+	return nodes;
+};
+
+const findCycles = (graph) => {
+	const cycles = [];
+	const visited = new Set();
+	const inStack = new Set();
+	const stack = [];
+
+	const dfs = (node) => {
+		visited.add(node);
+		inStack.add(node);
+		stack.push(node);
+
+		const neighbors = graph.get(node) ?? [];
+		for (const next of neighbors) {
+			if (!graph.has(next)) continue;
+			if (!visited.has(next)) {
+				dfs(next);
+				continue;
+			}
+			if (inStack.has(next)) {
+				const idx = stack.indexOf(next);
+				if (idx !== -1) cycles.push([...stack.slice(idx), next]);
+			}
+		}
+
+		stack.pop();
+		inStack.delete(node);
+	};
+
+	for (const node of graph.keys()) {
+		if (!visited.has(node)) dfs(node);
+	}
+
+	return cycles;
+};
+
+export default async function checkProviderGraph() {
+	const srcPath = path.join(process.cwd(), 'src');
+	try {
+		await fs.access(srcPath);
+	} catch {
+		console.error('❌ src folder not found in current workspace.');
+		process.exitCode = 1;
+		return;
+	}
+
+	const files = await listSourceFiles(srcPath);
+	const providers = [];
+
+	for (const filePath of files) {
+		const content = await fs.readFile(filePath, 'utf-8');
+		providers.push(...parseProviderGraphFromFile(content, filePath));
+	}
+
+	if (!providers.length) {
+		console.log('✅ No createBoundaryProvider declarations found.');
+		return;
+	}
+
+	const graph = new Map();
+	const issues = [];
+	const byName = new Map();
+
+	for (const provider of providers) {
+		if (byName.has(provider.name)) {
+			const existing = byName.get(provider.name);
+			issues.push({
+				file: provider.file,
+				line: provider.line,
+				message: `Provider graph ambiguity: duplicate provider id "${provider.name}" (first declared at ${toPosixPath(
+					path.relative(process.cwd(), existing.file)
+				)}:${existing.line})`
+			});
+			continue;
+		}
+		byName.set(provider.name, provider);
+		graph.set(provider.name, provider.dependsOn);
+	}
+
+	const cycles = findCycles(graph);
+	for (const cycle of cycles) {
+		const firstNode = byName.get(cycle[0] ?? '');
+		issues.push({
+			file: firstNode?.file ?? srcPath,
+			line: firstNode?.line ?? 1,
+			message: `Circular provider dependency detected: ${cycle.join(' -> ')}`
+		});
+	}
+
+	if (!issues.length) {
+		console.log(`✅ Provider graph check passed (${providers.length} providers).`);
+		return;
+	}
+
+	console.error('❌ Provider graph check failed:');
+	for (const issue of issues) {
+		console.error(`• ${toPosixPath(path.relative(process.cwd(), issue.file))}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/checkProviderGraph.ts

@@ -0,0 +1,234 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+type ProviderNode = {
+	name: string;
+	file: string;
+	line: number;
+	dependsOn: string[];
+};
+
+type GraphIssue = {
+	file: string;
+	line: number;
+	message: string;
+};
+
+const TARGET_EXTENSIONS = new Set(['.ts', '.js']);
+const IGNORED_DIRS = new Set(['node_modules', 'dist', '.svelte-kit', '.git']);
+
+const toPosixPath = (value: string): string => value.split(path.sep).join('/');
+
+const getLineByIndex = (content: string, index: number): number => {
+	let line = 1;
+	for (let i = 0; i < index; i += 1) {
+		if (content[i] === '\n') line += 1;
+	}
+	return line;
+};
+
+const listSourceFiles = async (rootDir: string): Promise<string[]> => {
+	const files: string[] = [];
+	const stack: string[] = [rootDir];
+
+	while (stack.length) {
+		const current = stack.pop();
+		if (!current) continue;
+
+		let entries: import('node:fs').Dirent[] = [];
+		try {
+			entries = await fs.readdir(current, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+
+		for (const entry of entries) {
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) stack.push(path.join(current, entry.name));
+				continue;
+			}
+
+			if (!entry.isFile()) continue;
+			const filePath = path.join(current, entry.name);
+			if (!TARGET_EXTENSIONS.has(path.extname(filePath))) continue;
+			files.push(filePath);
+		}
+	}
+
+	return files;
+};
+
+const findMatchingBracket = (content: string, startIndex: number, openChar: string, closeChar: string): number => {
+	let depth = 0;
+	for (let i = startIndex; i < content.length; i += 1) {
+		const ch = content[i];
+		if (ch === openChar) depth += 1;
+		if (ch === closeChar) {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+};
+
+const extractDependsOn = (configBlock: string): string[] => {
+	const dependsOnMatch = configBlock.match(/dependsOn\s*:\s*\{([\s\S]*?)\}/m);
+	if (!dependsOnMatch?.[1]) return [];
+
+	const block = dependsOnMatch[1];
+	const deps = new Set<string>();
+	const keyRegex = /([A-Za-z_$][A-Za-z0-9_$]*)\s*:/g;
+	let match: RegExpExecArray | null;
+	while ((match = keyRegex.exec(block)) !== null) {
+		const key = match[1];
+		if (key) deps.add(key);
+	}
+	return [...deps];
+};
+
+const parseProviderGraphFromFile = (content: string, filePath: string): ProviderNode[] => {
+	const nodes: ProviderNode[] = [];
+	const token = 'createBoundaryProvider(';
+	let fromIndex = 0;
+
+	while (fromIndex < content.length) {
+		const start = content.indexOf(token, fromIndex);
+		if (start === -1) break;
+
+		const openParenIndex = start + token.length - 1;
+		const closeParenIndex = findMatchingBracket(content, openParenIndex, '(', ')');
+		if (closeParenIndex === -1) break;
+
+		const fullCall = content.slice(openParenIndex + 1, closeParenIndex);
+		const idMatch = fullCall.match(/^\s*(['"`])([^'"`]+)\1\s*,/m);
+		const providerName = idMatch?.[2];
+		if (providerName) {
+			const objectStartInCall = fullCall.indexOf('{');
+			if (objectStartInCall !== -1) {
+				const absoluteObjectStart = openParenIndex + 1 + objectStartInCall;
+				const absoluteObjectEnd = findMatchingBracket(content, absoluteObjectStart, '{', '}');
+				const configBlock =
+					absoluteObjectEnd !== -1 ? content.slice(absoluteObjectStart, absoluteObjectEnd + 1) : fullCall.slice(objectStartInCall);
+
+				nodes.push({
+					name: providerName,
+					file: filePath,
+					line: getLineByIndex(content, start),
+					dependsOn: extractDependsOn(configBlock)
+				});
+			} else {
+				nodes.push({
+					name: providerName,
+					file: filePath,
+					line: getLineByIndex(content, start),
+					dependsOn: []
+				});
+			}
+		}
+
+		fromIndex = closeParenIndex + 1;
+	}
+
+	return nodes;
+};
+
+const findCycles = (graph: Map<string, string[]>): string[][] => {
+	const cycles: string[][] = [];
+	const visited = new Set<string>();
+	const inStack = new Set<string>();
+	const stack: string[] = [];
+
+	const dfs = (node: string): void => {
+		visited.add(node);
+		inStack.add(node);
+		stack.push(node);
+
+		const neighbors = graph.get(node) ?? [];
+		for (const next of neighbors) {
+			if (!graph.has(next)) continue;
+			if (!visited.has(next)) {
+				dfs(next);
+				continue;
+			}
+			if (inStack.has(next)) {
+				const idx = stack.indexOf(next);
+				if (idx !== -1) cycles.push([...stack.slice(idx), next]);
+			}
+		}
+
+		stack.pop();
+		inStack.delete(node);
+	};
+
+	for (const node of graph.keys()) {
+		if (!visited.has(node)) dfs(node);
+	}
+
+	return cycles;
+};
+
+export default async function checkProviderGraph(): Promise<void> {
+	const srcPath = path.join(process.cwd(), 'src');
+	try {
+		await fs.access(srcPath);
+	} catch {
+		console.error('❌ src folder not found in current workspace.');
+		process.exitCode = 1;
+		return;
+	}
+
+	const files = await listSourceFiles(srcPath);
+	const providers: ProviderNode[] = [];
+
+	for (const filePath of files) {
+		const content = await fs.readFile(filePath, 'utf-8');
+		providers.push(...parseProviderGraphFromFile(content, filePath));
+	}
+
+	if (!providers.length) {
+		console.log('✅ No createBoundaryProvider declarations found.');
+		return;
+	}
+
+	const graph = new Map<string, string[]>();
+	const issues: GraphIssue[] = [];
+	const byName = new Map<string, ProviderNode>();
+
+	for (const provider of providers) {
+		if (byName.has(provider.name)) {
+			const existing = byName.get(provider.name)!;
+			issues.push({
+				file: provider.file,
+				line: provider.line,
+				message: `Provider graph ambiguity: duplicate provider id "${provider.name}" (first declared at ${toPosixPath(
+					path.relative(process.cwd(), existing.file)
+				)}:${existing.line})`
+			});
+			continue;
+		}
+		byName.set(provider.name, provider);
+		graph.set(provider.name, provider.dependsOn);
+	}
+
+	const cycles = findCycles(graph);
+	for (const cycle of cycles) {
+		const firstNode = byName.get(cycle[0] ?? '');
+		issues.push({
+			file: firstNode?.file ?? srcPath,
+			line: firstNode?.line ?? 1,
+			message: `Circular provider dependency detected: ${cycle.join(' -> ')}`
+		});
+	}
+
+	if (!issues.length) {
+		console.log(`✅ Provider graph check passed (${providers.length} providers).`);
+		return;
+	}
+
+	console.error('❌ Provider graph check failed:');
+	for (const issue of issues) {
+		console.error(`• ${toPosixPath(path.relative(process.cwd(), issue.file))}:${issue.line} — ${issue.message}`);
+	}
+
+	process.exitCode = 1;
+}

package/src/checks/index.js

@@ -1,5 +1,6 @@
 export { default as checkPresenterNames } from './checkPresenterNames.js';
 export { default as checkProviderNames } from './checkProviderNames.js';
+export { default as checkProviderGraph } from './checkProviderGraph.js';
 export { default as checkDomain } from './checkDomain.js';
 export { default as checkLayerBoundaries } from './checkLayerBoundaries.js';
 export { default as checkFoldersStructure } from './checkFoldersStructure.js';

package/src/checks/index.ts

@@ -1,6 +1,8 @@
 export { default as checkPresenterNames } from './checkPresenterNames.js';
 export { default as checkProviderNames } from './checkProviderNames.js';
+export { default as checkProviderGraph } from './checkProviderGraph.js';
 export { default as checkDomain } from './checkDomain.js';
+export { default as checkImports } from './checkImports.js';
 export { default as checkLayerBoundaries } from './checkLayerBoundaries.js';
 export { default as checkFoldersStructure } from './checkFoldersStructure.js';
 export { default as checkInternal } from './checkInternal.js';

package/src/generate/module/repositoryModuleShared.ts

@@ -564,7 +564,7 @@ export const writeRepositoryInterface = async ({
 		.join('\n');
 
 	const content = `${imports.join('\n')}${imports.length ? '\n\n' : ''}export interface ${meta.repositoryInterfaceName} {\n${signatures ? `${signatures}\n` : ''}}\n`;
-	await fs.writeFile(path.join(portsPath, `${meta.repositoryInterfaceName}.ts`), content, 'utf-8');
+	await fs.writeFile(path.join(portsPath, `${toTypeFileName(meta.repositoryInterfaceName)}.ts`), content, 'utf-8');
 	await updateIndexTs(portsPath);
 };
 
@@ -598,7 +598,11 @@ export const createUseCasesForRepository = async ({
 	repositoryName: string;
 }): Promise<boolean> => {
 	const meta = getRepositoryMeta(repositoryName);
-	const interfacePath = path.join(resolveDomainRootPath(contextName, domainName), 'ports', `${meta.repositoryInterfaceName}.ts`);
+	const interfacePath = path.join(
+		resolveDomainRootPath(contextName, domainName),
+		'ports',
+		`${toTypeFileName(meta.repositoryInterfaceName)}.ts`
+	);
 
 	let interfaceContent = '';
 	try {