@azure-net/cli 5.1.0 → 6.0.0-next.2

package/src/generate/module/generatePresenter.ts

@@ -1,498 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import { toKebabCase, toPascalCase } from '../../utils/contextUtils.js';
-import { writeIfNotExists, updateIndexTs } from '../../utils/fileUtils.js';
-import { getConfigState, resolveContextAlias, selectContext } from './repositoryModuleShared.js';
-import { loadUserConfig } from '../../utils/loadConfig.js';
-import { getFoundationConstructImportPath, getFoundationConstructPath, getSharedState } from '../../utils/sharedFoundation.js';
-
-type MethodParam = { name: string; type: string };
-type RepositoryMethod = { name: string; params: MethodParam[]; responseType: string };
-type UseCasesInfo = { repositoryInterfaceName: string | null; domainName: string | null; methods: string[] };
-type ProviderInfo = { providerName: string; registeredKeys: string[] };
-
-const PRIMITIVE_TYPES = new Set(['string', 'number', 'boolean', 'unknown', 'void', 'null', 'undefined', 'bigint', 'symbol', 'never']);
-
-const parseProviderInfo = (content: string): ProviderInfo => {
-	const providerNameMatch = content.match(/export\s+const\s+(\w+)\s*=\s*createBoundaryProvider/);
-	const providerName = providerNameMatch?.[1] ?? 'ApplicationProvider';
-
-	const registerMatch = content.match(/register\s*:\s*\([^)]*\)\s*=>\s*\(\{([\s\S]*?)\}\)/m);
-	const registerBody = registerMatch?.[1] ?? '';
-	const keys: string[] = [];
-	const keyRegex = /([A-Za-z_]\w*)\s*:/g;
-	let keyMatch: RegExpExecArray | null;
-	while ((keyMatch = keyRegex.exec(registerBody)) !== null) {
-		const key = keyMatch[1];
-		if (key) keys.push(key);
-	}
-
-	return { providerName, registeredKeys: keys };
-};
-
-const parseUseCasesInfo = (content: string): UseCasesInfo => {
-	const interfaceImport = content.match(/import\s+type\s+\{\s*(\w+)\s*\}\s+from\s+['"]([^'"]+)['"]/);
-	const repositoryInterfaceName = interfaceImport?.[1] ?? null;
-	const domainImportPath = interfaceImport?.[2] ?? null;
-	const domainNameMatch = domainImportPath?.match(/\/layers\/domain\/([^'"]+)$/);
-	const domainName = domainNameMatch?.[1] ?? null;
-
-	const methods: string[] = [];
-	const declareRegex = /declare\s+(\w+)\s*:\s*\w+\['\w+'\];/g;
-	let declareMatch: RegExpExecArray | null;
-	while ((declareMatch = declareRegex.exec(content)) !== null) {
-		const methodName = declareMatch[1];
-		if (methodName) methods.push(methodName);
-	}
-
-	return { repositoryInterfaceName, domainName, methods };
-};
-
-const parseRepositoryInterfaceMethods = (content: string): RepositoryMethod[] => {
-	const methods: RepositoryMethod[] = [];
-	const regex = /(\w+)\(([^)]*)\)\s*:\s*Promise<([^>]+)>;/g;
-	let match: RegExpExecArray | null;
-	while ((match = regex.exec(content)) !== null) {
-		const methodName = match[1];
-		const paramsChunk = match[2];
-		const responseTypeChunk = match[3];
-		if (!methodName || paramsChunk === undefined || !responseTypeChunk) continue;
-		const paramsRaw = paramsChunk.trim();
-		const params: MethodParam[] = paramsRaw
-			? paramsRaw.split(',').map((part) => {
-					const [name, ...typeParts] = part.trim().split(':');
-					return { name: String(name ?? '').trim(), type: typeParts.join(':').trim() };
-				})
-			: [];
-		methods.push({
-			name: methodName,
-			params,
-			responseType: responseTypeChunk.trim()
-		});
-	}
-	return methods;
-};
-
-const findRepositoryByInterface = async (
-	contextName: string,
-	repositoryInterfaceName: string
-): Promise<{ filePath: string; content: string } | null> => {
-	const repositoriesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'infrastructure', 'http', 'repositories');
-	try {
-		const files = await fs.readdir(repositoriesPath);
-		for (const fileName of files) {
-			if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
-			const absolute = path.join(repositoriesPath, fileName);
-			const content = await fs.readFile(absolute, 'utf-8');
-			if (content.includes(`implements ${repositoryInterfaceName}`)) {
-				return { filePath: absolute, content };
-			}
-		}
-		return null;
-	} catch {
-		return null;
-	}
-};
-
-const parseRepositoryHttpMethods = (content: string): Map<string, string> => {
-	const methods = new Map<string, string>();
-	const regex = /public\s+async\s+(\w+)\([^)]*\)\s*\{([\s\S]*?)\n\t\}/g;
-	let match: RegExpExecArray | null;
-	while ((match = regex.exec(content)) !== null) {
-		const methodName = match[1];
-		if (!methodName) continue;
-		const body = match[2] ?? '';
-		const httpMatch = body.match(/http\.(get|post|put|delete|head|options|patch)\(/);
-		if (httpMatch?.[1]) methods.set(methodName, httpMatch[1]);
-	}
-	return methods;
-};
-
-const getSharedPresenterFactories = async (): Promise<string[]> => {
-	const { sharedContext } = await getSharedState();
-	const presenterPath = getFoundationConstructPath(sharedContext.name, 'presenter');
-	try {
-		const files = await fs.readdir(presenterPath);
-		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
-	} catch {
-		return [];
-	}
-};
-
-const getSharedSchemaFactories = async (): Promise<string[]> => {
-	const { sharedContext } = await getSharedState();
-	const schemaPath = getFoundationConstructPath(sharedContext.name, 'schema');
-	try {
-		const files = await fs.readdir(schemaPath);
-		return files.filter((item) => item.endsWith('.ts') && item !== 'index.ts').map((item) => item.replace(/\.ts$/, ''));
-	} catch {
-		return [];
-	}
-};
-
-const normalizePresenterName = (rawName: string | undefined, fallbackUseCasesName: string): string => {
-	const fallback = fallbackUseCasesName.replace(/UseCases$/, '') || 'Module';
-	const source = String(rawName ?? '').trim() || fallback;
-	const normalized = toPascalCase(source);
-	return normalized.endsWith('Presenter') ? normalized : `${normalized}Presenter`;
-};
-
-const isPrimitive = (typeName: string): boolean => PRIMITIVE_TYPES.has(String(typeName ?? '').trim());
-
-const normalizeTypeImports = (types: string[]): string[] => Array.from(new Set(types.filter((typeName) => !isPrimitive(typeName))));
-const isPathParamName = (name: string): boolean => name === 'pathParam' || name === 'path';
-const toTypeFileName = (typeName: string): string => String(typeName ?? '').replace(/^I/, '') || 'Type';
-
-const buildMethodInvocation = (
-	method: RepositoryMethod & { httpMethod: string },
-	useCasesName: string,
-	schemaByMethod: Map<string, { constName: string }>
-): string => {
-	const paramsSignature = method.params.map((item) => `${item.name}: ${item.type}`).join(', ');
-	const argNames = method.params.map((item) => item.name);
-	const requestParam = method.params.find((item) => !isPathParamName(item.name));
-	const schemaInfo = schemaByMethod.get(method.name) ?? null;
-	const args = argNames.map((argName) => {
-		if (schemaInfo && requestParam && argName === requestParam.name) {
-			return `${schemaInfo.constName}.from(${argName}).json()`;
-		}
-		return argName;
-	});
-
-	const httpMethod = method.httpMethod;
-	if (httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options') {
-		return `\tconst ${method.name} = (${paramsSignature}) => createAsyncResource(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
-	}
-
-	const responseType = method.responseType;
-	const requestType = requestParam?.type ?? null;
-	let generic = `<${responseType}`;
-	if (requestType) generic += `, ${requestType}`;
-	generic += '>';
-
-	return `\tconst ${method.name} = async (${paramsSignature}) =>\n\t\tawait createAsyncAction${generic}(() => ${useCasesName}.${method.name}(${args.join(', ')}));`;
-};
-
-const getApplicationProviderFile = async (contextName: string): Promise<string | null> => {
-	const providersPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'providers');
-	const targetPath = path.join(providersPath, 'ApplicationProvider.ts');
-	try {
-		await fs.access(targetPath);
-		return targetPath;
-	} catch {
-		const files = await fs.readdir(providersPath);
-		const candidate = files.find((item) => item.endsWith('.ts') && item !== 'index.ts');
-		return candidate ? path.join(providersPath, candidate) : null;
-	}
-};
-
-const resolveDomainInterfaceFile = async ({
-	contextName,
-	domainName,
-	interfaceName
-}: {
-	contextName: string;
-	domainName: string;
-	interfaceName: string;
-}): Promise<string | null> => {
-	const portsPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'domain', domainName, 'ports');
-	const preferredPath = path.join(portsPath, `${toTypeFileName(interfaceName)}.ts`);
-	const legacyPath = path.join(portsPath, `${interfaceName}.ts`);
-
-	for (const candidate of [preferredPath, legacyPath]) {
-		try {
-			await fs.access(candidate);
-			return candidate;
-		} catch {
-			// Try the next candidate.
-		}
-	}
-
-	try {
-		const files = await fs.readdir(portsPath);
-		for (const fileName of files) {
-			if (!fileName.endsWith('.ts') || fileName === 'index.ts') continue;
-			const candidate = path.join(portsPath, fileName);
-			const content = await fs.readFile(candidate, 'utf-8');
-			const escapedName = interfaceName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-			if (new RegExp(`export\\s+interface\\s+${escapedName}\\b`).test(content)) {
-				return candidate;
-			}
-		}
-	} catch {
-		return null;
-	}
-
-	return null;
-};
-
-type GeneratePresenterOptions = {
-	contextName?: string;
-	useCasesName?: string;
-};
-
-export default async function generatePresenter(options: GeneratePresenterOptions = {}): Promise<void> {
-	let contextName: string | null = options.contextName ? String(options.contextName) : null;
-	if (!contextName) {
-		contextName = await selectContext('Select context for presenter:');
-	}
-	if (!contextName) {
-		process.exitCode = 1;
-		return;
-	}
-
-	const appProviderFile = await getApplicationProviderFile(contextName);
-	if (!appProviderFile) {
-		console.error('❌ ApplicationProvider file was not found.');
-		process.exitCode = 1;
-		return;
-	}
-
-	const appProviderContent = await fs.readFile(appProviderFile, 'utf-8');
-	const providerInfo = parseProviderInfo(appProviderContent);
-
-	const useCasesPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'application', 'use-cases');
-	let useCasesFiles: string[] = [];
-	try {
-		useCasesFiles = (await fs.readdir(useCasesPath))
-			.filter((item) => item.endsWith('.ts') && item !== 'index.ts')
-			.map((item) => item.replace(/\.ts$/, ''));
-	} catch {
-		// ignore
-	}
-
-	const registeredUseCases = useCasesFiles.filter((item) => providerInfo.registeredKeys.includes(item));
-	if (!registeredUseCases.length) {
-		console.error('❌ No registered UseCases were found in ApplicationProvider register().');
-		process.exitCode = 1;
-		return;
-	}
-
-	let useCasesName = options.useCasesName ? String(options.useCasesName) : '';
-	if (!useCasesName) {
-		const { selectedUseCases } = await prompts({
-			type: 'select',
-			name: 'selectedUseCases',
-			message: 'Select UseCases:',
-			choices: registeredUseCases.map((item) => ({ title: item, value: item })),
-			initial: 0
-		});
-		useCasesName = String(selectedUseCases ?? '');
-	}
-
-	if (!registeredUseCases.includes(useCasesName)) {
-		console.error(`❌ UseCases "${useCasesName}" is not registered in ApplicationProvider.`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const useCasesFile = path.join(useCasesPath, `${useCasesName}.ts`);
-	const useCasesContent = await fs.readFile(useCasesFile, 'utf-8');
-	const useCasesInfo = parseUseCasesInfo(useCasesContent);
-	if (!useCasesInfo.repositoryInterfaceName || !useCasesInfo.domainName) {
-		console.error('❌ Unable to parse repository interface import from UseCases.');
-		process.exitCode = 1;
-		return;
-	}
-
-	const repositoryInfo = await findRepositoryByInterface(contextName, useCasesInfo.repositoryInterfaceName);
-	if (!repositoryInfo) {
-		console.error(`❌ Repository implementing ${useCasesInfo.repositoryInterfaceName} was not found.`);
-		process.exitCode = 1;
-		return;
-	}
-
-	const repositoryHttpMethods = parseRepositoryHttpMethods(repositoryInfo.content);
-	const domainPortsInterfacePath = await resolveDomainInterfaceFile({
-		contextName,
-		domainName: useCasesInfo.domainName,
-		interfaceName: useCasesInfo.repositoryInterfaceName
-	});
-	if (!domainPortsInterfacePath) {
-		console.error(
-			`❌ Repository interface "${useCasesInfo.repositoryInterfaceName}" was not found in ${path.join(
-				process.cwd(),
-				'src',
-				'app',
-				contextName,
-				'layers',
-				'domain',
-				useCasesInfo.domainName,
-				'ports'
-			)}`
-		);
-		process.exitCode = 1;
-		return;
-	}
-	const repositoryInterfaceContent = await fs.readFile(domainPortsInterfacePath, 'utf-8');
-	const repositoryMethods = parseRepositoryInterfaceMethods(repositoryInterfaceContent).filter((method) =>
-		useCasesInfo.methods.includes(method.name)
-	);
-
-	const { presenterNameRaw } = await prompts({
-		type: 'text',
-		name: 'presenterNameRaw',
-		message: 'Presenter name (optional):'
-	});
-
-	const presenterName = normalizePresenterName(presenterNameRaw, useCasesName);
-	const presenterFolder = toKebabCase(presenterName.replace(/Presenter$/, ''));
-	const presentationPath = path.join(process.cwd(), 'src', 'app', contextName, 'layers', 'presentation', presenterFolder);
-	await fs.mkdir(presentationPath, { recursive: true });
-
-	const { contexts, sharedAlias } = await getConfigState();
-	const contextAlias = resolveContextAlias(contexts, contextName);
-	const presenterImportPath = getFoundationConstructImportPath(sharedAlias, 'presenter');
-	const schemaFactoryImportPath = getFoundationConstructImportPath(sharedAlias, 'schema');
-
-	let presenterFactory = String((await loadUserConfig()).defaultPresenterFactory ?? '').trim();
-	let useNativePresenter = false;
-	if (!presenterFactory) {
-		const availableFactories = await getSharedPresenterFactories();
-		const { selectedFactory } = await prompts({
-			type: 'select',
-			name: 'selectedFactory',
-			message: 'Select presenter factory:',
-			choices: [
-				...availableFactories.map((item) => ({ title: item, value: item })),
-				{ title: 'Native createPresenter', value: '__native__' }
-			],
-			initial: 0
-		});
-
-		if (selectedFactory === '__native__') {
-			useNativePresenter = true;
-			presenterFactory = 'createPresenter';
-		} else {
-			presenterFactory = String(selectedFactory ?? '');
-		}
-	}
-
-	if (!presenterFactory) {
-		useNativePresenter = true;
-		presenterFactory = 'createPresenter';
-	}
-
-	const mutationMethods = repositoryMethods.filter((method) => {
-		const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
-		return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
-	});
-
-	let schemaFactory = String((await loadUserConfig()).defaultSchemaFactory ?? '').trim();
-	let schemaFactoryResolved = false;
-	const schemaByMethod = new Map<string, { constName: string }>();
-	const schemaImports: string[] = [];
-	let schemaIndexNeeded = false;
-
-	if (mutationMethods.length) {
-		for (const method of mutationMethods) {
-			const requestParam = method.params.find((item) => !isPathParamName(item.name));
-			if (!requestParam) continue;
-
-			const { shouldCreateSchema } = await prompts({
-				type: 'confirm',
-				name: 'shouldCreateSchema',
-				message: `Create schema for "${method.name}"?`,
-				initial: false
-			});
-
-			if (!shouldCreateSchema) continue;
-
-			if (!schemaFactoryResolved) {
-				if (!schemaFactory) {
-					const availableSchemas = await getSharedSchemaFactories();
-					if (!availableSchemas.length) {
-						console.error('❌ No schema factories found in shared foundation constructs/schema.');
-						process.exitCode = 1;
-						return;
-					}
-
-					const { selectedSchemaFactory } = await prompts({
-						type: 'select',
-						name: 'selectedSchemaFactory',
-						message: 'Select schema factory:',
-						choices: availableSchemas.map((item) => ({ title: item, value: item })),
-						initial: 0
-					});
-
-					schemaFactory = String(selectedSchemaFactory ?? '');
-				}
-
-				schemaFactoryResolved = true;
-			}
-
-			const schemaConstName = `${toPascalCase(method.name)}${presenterName}Schema`;
-			const schemaFileName = `${schemaConstName}.ts`;
-			const schemaPath = path.join(presentationPath, 'schema');
-			await fs.mkdir(schemaPath, { recursive: true });
-			schemaIndexNeeded = true;
-
-			const schemaContent = `import { ${schemaFactory} } from '${schemaFactoryImportPath}';
-import type { ${requestParam.type} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';
-
-export const ${schemaConstName} = ${schemaFactory}<${requestParam.type}>()
-\t.rules((rules) => ({}))
-\t.create();
-`;
-
-			await writeIfNotExists(path.join(schemaPath, schemaFileName), schemaContent);
-			schemaByMethod.set(method.name, { constName: schemaConstName });
-			schemaImports.push(schemaConstName);
-		}
-	}
-
-	if (schemaIndexNeeded) {
-		await updateIndexTs(path.join(presentationPath, 'schema'));
-	}
-
-	const hasGetLike = repositoryMethods.some((method) => {
-		const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
-		return httpMethod === 'get' || httpMethod === 'head' || httpMethod === 'options';
-	});
-	const hasMutation = repositoryMethods.some((method) => {
-		const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
-		return httpMethod !== 'get' && httpMethod !== 'head' && httpMethod !== 'options';
-	});
-
-	const helperParams = [hasGetLike ? 'createAsyncResource' : null, hasMutation ? 'createAsyncAction' : null].filter(Boolean).join(', ');
-
-	const typeImports = normalizeTypeImports(
-		repositoryMethods.flatMap((method) => [method.responseType, ...method.params.map((item) => item.type)])
-	);
-
-	const methodsCode = repositoryMethods
-		.map((method) => {
-			const httpMethod = repositoryHttpMethods.get(method.name) ?? 'get';
-			return buildMethodInvocation({ ...method, httpMethod }, useCasesName, schemaByMethod);
-		})
-		.join('\n\n');
-
-	const factoryImport = useNativePresenter
-		? `import { createPresenter } from '@azure-net/kit/delivery';`
-		: `import { ${presenterFactory} } from '${presenterImportPath}';`;
-
-	const schemaImportLine = schemaImports.length ? `import { ${Array.from(new Set(schemaImports)).join(', ')} } from './schema';` : '';
-	const typeImportLine = typeImports.length
-		? `import type { ${typeImports.join(', ')} } from '${contextAlias}/layers/domain/${useCasesInfo.domainName}';`
-		: '';
-
-	const presenterId = `${toPascalCase(contextName)}${presenterName}`;
-	const presenterContent = `${factoryImport}
-import { ${providerInfo.providerName} } from '${contextAlias}/layers/application/providers';
-${typeImportLine}
-${schemaImportLine}
-
-export const ${presenterName} = ${presenterFactory}('${presenterId}', ({ ${helperParams} }) => {
-\tconst { ${useCasesName} } = ${providerInfo.providerName}();
-
-${methodsCode ? `${methodsCode}\n` : ''}
-\treturn { ${repositoryMethods.map((method) => method.name).join(', ')} };
-});
-`;
-
-	await writeIfNotExists(path.join(presentationPath, `${presenterName}.ts`), presenterContent);
-	await fs.writeFile(path.join(presentationPath, 'index.ts'), `export * from './${presenterName}';\n`, 'utf-8');
-
-	console.log(`✅ Presenter generated: ${path.join(presentationPath, `${presenterName}.ts`)}`);
-}

package/src/generate/module/generateRepository.ts

@@ -1,158 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import prompts from 'prompts';
-import {
-	buildRepositoryContent,
-	createUseCasesForRepository,
-	ensureRepositoryName,
-	getConfigState,
-	getDomainTypes,
-	getRepositoryMeta,
-	promptMethodsBatch,
-	resolveContextAlias,
-	resolveRepositoriesPath,
-	selectContext,
-	selectDatasource,
-	selectDomain,
-	writeRepositoryInterface
-} from './repositoryModuleShared.js';
-import { updateIndexTs, writeIfNotExists } from '../../utils/fileUtils.js';
-
-type GenerateRepositoryOptions = {
-	contextName?: string;
-	domainName?: string;
-	forceCreateUseCases?: boolean;
-};
-
-type GenerateRepositoryResult = {
-	contextName: string;
-	domainName: string;
-	repositoryName: string;
-	useCasesName: string;
-	useCasesCreated: boolean;
-};
-
-export default async function generateRepository(options: GenerateRepositoryOptions = {}): Promise<GenerateRepositoryResult | null> {
-	let contextName: string | null = options.contextName ? String(options.contextName) : null;
-	if (!contextName) {
-		contextName = await selectContext('Select context for repository:');
-	}
-	if (!contextName) {
-		process.exitCode = 1;
-		return null;
-	}
-
-	let domainName: string | null = options.domainName ? String(options.domainName) : null;
-	if (!domainName) {
-		domainName = await selectDomain(contextName);
-	}
-	if (!domainName) {
-		process.exitCode = 1;
-		return null;
-	}
-
-	const { repositoryNameRaw } = await prompts({
-		type: 'text',
-		name: 'repositoryNameRaw',
-		message: 'Repository name:',
-		validate: (value: string) => (String(value ?? '').trim().length > 0 ? true : 'Repository name is required')
-	});
-
-	const className = ensureRepositoryName(repositoryNameRaw);
-	const meta = getRepositoryMeta(className);
-
-	const datasource = await selectDatasource(contextName);
-	if (!datasource) {
-		process.exitCode = 1;
-		return null;
-	}
-
-	const domainTypes = await getDomainTypes(contextName, domainName);
-	const { methodsCountRaw } = await prompts({
-		type: 'number',
-		name: 'methodsCountRaw',
-		message: 'How many methods to create?',
-		initial: 1,
-		min: 0
-	});
-
-	const methodsCount = Number(methodsCountRaw ?? 0);
-	if (!Number.isFinite(methodsCount) || methodsCount < 0) {
-		console.error('❌ Invalid methods count.');
-		process.exitCode = 1;
-		return null;
-	}
-
-	const methods = await promptMethodsBatch(domainTypes, methodsCount);
-	if (!methods) {
-		process.exitCode = 1;
-		return null;
-	}
-
-	const { contexts } = await getConfigState();
-	const contextAlias = resolveContextAlias(contexts, contextName);
-	const repositoriesPath = resolveRepositoriesPath(contextName);
-	await fs.mkdir(repositoriesPath, { recursive: true });
-	const repositoryPath = path.join(repositoriesPath, `${meta.className}.ts`);
-
-	await writeRepositoryInterface({
-		contextName,
-		domainName,
-		meta,
-		methods
-	});
-
-	const repositoryContent = buildRepositoryContent({
-		meta,
-		contextAlias,
-		domainName,
-		datasource,
-		methods
-	});
-
-	const created = await writeIfNotExists(repositoryPath, repositoryContent);
-	await updateIndexTs(repositoriesPath);
-
-	if (!created) {
-		console.warn(`⚠️ Repository "${meta.className}" already exists. File was not overwritten.`);
-		process.exitCode = 1;
-		return null;
-	}
-
-	const { shouldCreateUseCases } = await prompts({
-		type: 'confirm',
-		name: 'shouldCreateUseCases',
-		message: 'Create UseCases for this repository?',
-		initial: true
-	});
-
-	let useCasesCreated = false;
-	if (shouldCreateUseCases) {
-		await createUseCasesForRepository({
-			contextName,
-			contextAlias,
-			domainName,
-			repositoryName: meta.className
-		});
-		useCasesCreated = true;
-	}
-
-	if (!shouldCreateUseCases && options.forceCreateUseCases) {
-		await createUseCasesForRepository({
-			contextName,
-			contextAlias,
-			domainName,
-			repositoryName: meta.className
-		});
-		useCasesCreated = true;
-	}
-
-	console.log(`✅ Repository generated: ${repositoryPath}`);
-	return {
-		contextName,
-		domainName,
-		repositoryName: meta.className,
-		useCasesName: meta.useCasesClassName,
-		useCasesCreated
-	};
-}