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

package/src/scaffolds/createTranslationManager.js

@@ -1,19 +1,24 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
+import ts from 'typescript';
+import { formatConfig } from '../utils/viteConfig.js';
+import { toPascalCase } from '../utils/contextUtils.js';
 import { writeIfNotExists } from '../utils/fileUtils.js';
 import { getLocalizationPath, getSharedState } from '../utils/sharedFoundation.js';
 const parseLocales = (rawLocales) => {
-	const parsed = String(rawLocales ?? '')
-		.split(',')
-		.map((item) => item.trim().toLowerCase())
-		.filter(Boolean);
-	const unique = Array.from(new Set(parsed));
-	return unique.length ? unique : ['en', 'ru'];
+    const parsed = String(rawLocales ?? '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter((locale) => /^[A-Za-z]+(?:-[A-Za-z0-9]+)*$/.test(locale));
+    const unique = Array.from(new Set(parsed));
+    return unique.length ? unique : ['en', 'ru'];
 };
-const createTranslationIndexTemplate = (defaultLocale) => `import { messages } from './locales/index.js';
-import { createTranslations, type Path } from '@azure-net/kit/i18n';
+const createTranslationIndexTemplate = (defaultLocale) => `import { messages } from './Locales';
+import { createTranslations } from '@azure-net/kit/i18n';
+import type { Path } from '@azure-net/kit/i18n';
 
+// program.ts: createApp((app) => app.useTranslations(TranslationManager))
 export const TranslationManager = createTranslations({
 \tmessages,
 \tinitLang: '${defaultLocale}',
@@ -29,39 +34,81 @@ export type TranslationParam = MessageKeys | string | TranslationExtended;
 export type AvailableLocales = keyof typeof messages;
 `;
 const createLocalesIndexTemplate = (locales) => {
-	const lines = locales.map((locale) => `\t${locale}: () => import('./${locale}/index.js').then((res) => res.default)`);
-	return `export const messages = {\n${lines.join(',\n')}\n};\n`;
+    const lines = locales.map((locale) => `\t'${locale}': () => import('./${toPascalCase(locale)}').then((res) => res.default)`);
+    return `export const messages = {\n${lines.join(',\n')}\n};\n`;
 };
 const createLocaleTemplate = () => `export default {
 \ttest: 'test'
 };
 `;
+async function connectTranslations(translationRoot) {
+    const file = path.join(process.cwd(), 'src/program.ts');
+    let specifier = path.relative(path.dirname(file), translationRoot).split(path.sep).join('/');
+    if (!specifier.startsWith('.'))
+        specifier = `./${specifier}`;
+    let content;
+    try {
+        content = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        content = "import { createApp } from '@azure-net/kit';\nexport const { register } = createApp((app) => app);\n";
+    }
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    let body;
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'createApp') {
+            const callback = node.arguments[0];
+            if (callback &&
+                ts.isArrowFunction(callback) &&
+                ts.isIdentifier(callback.body) &&
+                callback.parameters[0]?.name.getText(source) === callback.body.text)
+                body = callback.body;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    // Only modify the empty generated bootstrap, not application-specific pipelines/imports.
+    if (!body || /\bTranslationManager\b/.test(content)) {
+        console.log(`Connect translations in ${file}: app.useTranslations(TranslationManager), imported from '${specifier}'. Existing bootstrap preserved.`);
+        return;
+    }
+    content =
+        `import { TranslationManager } from '${specifier}';\n` +
+            content.slice(0, body.end) +
+            '.useTranslations(TranslationManager)' +
+            content.slice(body.end);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, await formatConfig(content, file));
+}
 export default async function createTranslationManager() {
-	const { localesRaw } = await prompts({
-		type: 'text',
-		name: 'localesRaw',
-		message: 'Enter locales (comma separated):',
-		initial: 'en, ru'
-	});
-	const locales = parseLocales(String(localesRaw ?? 'en, ru'));
-	const { defaultLocale } = await prompts({
-		type: 'select',
-		name: 'defaultLocale',
-		message: 'Choose default locale:',
-		choices: locales.map((locale) => ({ title: locale, value: locale })),
-		initial: 0
-	});
-	const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
-	const { sharedContext } = await getSharedState();
-	const translationRoot = getLocalizationPath(sharedContext.name);
-	const localesRoot = path.join(translationRoot, 'locales');
-	await fs.mkdir(localesRoot, { recursive: true });
-	await writeIfNotExists(path.join(translationRoot, 'index.ts'), createTranslationIndexTemplate(selectedDefaultLocale));
-	await writeIfNotExists(path.join(localesRoot, 'index.ts'), createLocalesIndexTemplate(locales));
-	for (const locale of locales) {
-		const localeDir = path.join(localesRoot, locale);
-		await fs.mkdir(localeDir, { recursive: true });
-		await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
-	}
-	console.log(`✅ Translation manager created: ${translationRoot}`);
+    const { localesRaw } = await prompts({
+        type: 'text',
+        name: 'localesRaw',
+        message: 'Enter locales (comma separated):',
+        initial: 'en, ru'
+    });
+    const locales = parseLocales(String(localesRaw ?? 'en, ru'));
+    const { defaultLocale } = await prompts({
+        type: 'select',
+        name: 'defaultLocale',
+        message: 'Choose default locale:',
+        choices: locales.map((locale) => ({ title: locale, value: locale })),
+        initial: 0
+    });
+    const selectedDefaultLocale = String(defaultLocale ?? locales[0] ?? 'en');
+    const { sharedContext } = await getSharedState();
+    const translationRoot = getLocalizationPath(sharedContext.name);
+    const localesRoot = path.join(translationRoot, 'Locales');
+    await fs.mkdir(localesRoot, { recursive: true });
+    await writeIfNotExists(path.join(translationRoot, 'index.ts'), createTranslationIndexTemplate(selectedDefaultLocale));
+    await writeIfNotExists(path.join(localesRoot, 'index.ts'), createLocalesIndexTemplate(locales));
+    for (const locale of locales) {
+        const localeDir = path.join(localesRoot, toPascalCase(locale));
+        await fs.mkdir(localeDir, { recursive: true });
+        await writeIfNotExists(path.join(localeDir, 'index.ts'), createLocaleTemplate());
+    }
+    await connectTranslations(translationRoot);
+    console.log(`✅ Translation manager created: ${translationRoot}`);
 }

package/src/scaffolds/index.js

@@ -1,8 +1,6 @@
 export { default as createCoreSchema } from './createCoreSchema.js';
 export { default as createTranslationManager } from './createTranslationManager.js';
-export { default as createPresenterFactory } from './createPresenterFactory.js';
 export { default as createSchemaRule } from './createSchemaRule.js';
 export { default as createResponse } from './createResponse.js';
 export { default as createDatasource } from './createDatasource.js';
-export { default as createDatasourceProvider } from './createDatasourceProvider.js';
 export { default as createProgram } from './createProgram.js';

package/src/scaffolds/registerDatasource.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import ts from 'typescript';
+import { formatConfig } from '../utils/viteConfig.js';
+import { getPlatformPath } from '../utils/architecture.js';
+/** Only initialize an empty generated DI; never replace application-specific registrations. */
+export async function registerDatasource(className) {
+    const file = path.join(getPlatformPath(), 'Foundation/DI/ApplicationProvider.ts');
+    let content;
+    try {
+        content = await fs.readFile(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        console.warn(`Register ${className} inside ApplicationProvider.register.`);
+        return;
+    }
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+    let body;
+    const visit = (n) => {
+        if (ts.isPropertyAssignment(n) &&
+            ts.isIdentifier(n.name) &&
+            n.name.text === 'register' &&
+            ts.isArrowFunction(n.initializer) &&
+            !ts.isBlock(n.initializer.body)) {
+            let value = n.initializer.body;
+            while (ts.isParenthesizedExpression(value))
+                value = value.expression;
+            if (ts.isObjectLiteralExpression(value) && !value.properties.length)
+                body = n.initializer.body;
+        }
+    };
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) ||
+                declaration.name.text !== 'ApplicationProvider' ||
+                !declaration.initializer ||
+                !ts.isCallExpression(declaration.initializer))
+                continue;
+            const options = declaration.initializer.arguments[1];
+            if (options && ts.isObjectLiteralExpression(options))
+                for (const property of options.properties)
+                    visit(property);
+        }
+    }
+    if (!body || content.includes(className)) {
+        console.warn(`Existing DI preserved. Add const datasource = new ${className}({}) inside ApplicationProvider.register and pass it to repositories.`);
+        return;
+    }
+    content =
+        content.slice(0, body.getStart(source)) +
+            `{\nconst datasource = new ${className}({});\n// Pass datasource to repositories and return UseCases factories below.\nreturn {};\n}` +
+            content.slice(body.end);
+    content = `import { ${className} } from '#platform/Foundation/Datasource';\n` + content;
+    await fs.writeFile(file, await formatConfig(content, file));
+}

package/src/scaffolds/updateDefaultFactoryConfig.js

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import { flattenConfigLiterals } from '../utils/flattenConfig.js';
+export function updateDefaultFactoryConfig(content, key, name) {
+    content = flattenConfigLiterals(content);
+    if (!content.trim())
+        return `export default {\n\t${key}: ${JSON.stringify(name)}\n};\n`;
+    const source = ts.createSourceFile('azure-net.config.ts', content, ts.ScriptTarget.Latest, true);
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported || exported.isExportEquals)
+        throw new Error('Cannot update factory default: expected a default-exported config.');
+    const expression = exported.expression;
+    if (ts.isObjectLiteralExpression(expression)) {
+        const lastSpread = expression.properties.reduce((last, item, index) => (ts.isSpreadAssignment(item) ? index : last), -1);
+        const property = [...expression.properties.slice(lastSpread + 1)]
+            .reverse()
+            .find((item) => ts.isPropertyAssignment(item) && (ts.isIdentifier(item.name) || ts.isStringLiteral(item.name)) && item.name.text === key);
+        if (property && ts.isPropertyAssignment(property)) {
+            if (ts.isStringLiteral(property.initializer) && property.initializer.text === name)
+                return content;
+            return content.slice(0, property.initializer.getStart(source)) + JSON.stringify(name) + content.slice(property.initializer.end);
+        }
+        const last = expression.properties.at(-1);
+        let result = content.slice(0, expression.end - 1) + `\n\t${key}: ${JSON.stringify(name)}\n` + content.slice(expression.end - 1);
+        if (last && !expression.properties.hasTrailingComma)
+            result = result.slice(0, last.end) + ',' + result.slice(last.end);
+        return result;
+    }
+    // Preserve custom config expressions without executing or reconstructing their contents.
+    const replacement = `{ ...(${expression.getText(source)}), ${key}: ${JSON.stringify(name)} }`;
+    return content.slice(0, expression.getStart(source)) + replacement + content.slice(expression.end);
+}

package/src/utils/architecture.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import prompts from 'prompts';
+import { writeIfNotExists } from './fileUtils.js';
+export const SHARED_CONTEXT = 'SharedKernel';
+export const SHARED_WORKSPACE = 'Shared';
+export const ARCHITECTURE_ALIASES = {
+    '#contexts': './src/app/Contexts',
+    '#presentation': './src/app/Presentation',
+    '#platform': './src/app/Platform'
+};
+export const CONTEXT_DIRS = [
+    'Domain/Entities',
+    'Domain/Ports',
+    'Domain/Enums',
+    'Application/UseCases',
+    'Infrastructure/Repositories'
+];
+export const PRESENTATION_DIRS = ['Ui', 'Scopes', 'Shell'];
+export function normalizePascalName(value) {
+    const raw = value.trim();
+    if (!/^[A-Za-z][A-Za-z0-9 _-]*$/.test(raw))
+        throw new Error(`Invalid architecture name: "${value}". Use letters, numbers, spaces, hyphens or underscores.`);
+    return raw
+        .split(/[-_\s]+/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+export const getAppPath = (cwd = process.cwd()) => path.join(cwd, 'src', 'app');
+export const getContextsPath = (cwd = process.cwd()) => path.join(getAppPath(cwd), 'Contexts');
+export const getContextPath = (context, cwd = process.cwd()) => path.join(getContextsPath(cwd), normalizePascalName(context));
+export const getPresentationPath = (workspace, cwd = process.cwd()) => workspace ? path.join(getAppPath(cwd), 'Presentation', normalizePascalName(workspace)) : path.join(getAppPath(cwd), 'Presentation');
+export const getPlatformPath = (cwd = process.cwd()) => path.join(getAppPath(cwd), 'Platform');
+export const getContextImportPath = (context) => `#contexts/${normalizePascalName(context)}`;
+export const getPresentationImportPath = (workspace) => workspace ? `#presentation/${normalizePascalName(workspace)}` : '#presentation';
+async function directories(root) {
+    try {
+        return (await fs.readdir(root, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+export const discoverContexts = async (cwd = process.cwd()) => (await directories(getContextsPath(cwd))).filter((name) => /^[A-Z][A-Za-z0-9]*$/.test(name));
+export const discoverPresentationWorkspaces = async (cwd = process.cwd()) => (await directories(getPresentationPath(undefined, cwd))).filter((name) => !PRESENTATION_DIRS.includes(name) && /^[A-Z][A-Za-z0-9]*$/.test(name));
+export async function ensureContextStructure(context, cwd = process.cwd()) {
+    const name = normalizePascalName(context);
+    for (const dir of CONTEXT_DIRS) {
+        await writeIfNotExists(path.join(getContextPath(name, cwd), dir, 'index.ts'), 'export {};\n');
+    }
+    return name;
+}
+export async function ensurePresentationStructure(workspace, cwd = process.cwd()) {
+    for (const dir of PRESENTATION_DIRS)
+        await fs.mkdir(path.join(getPresentationPath(workspace, cwd), dir), { recursive: true });
+}
+export async function selectContext(message = 'Select context:') {
+    await ensureContextStructure(SHARED_CONTEXT);
+    const names = await discoverContexts();
+    const result = await prompts({
+        type: 'select',
+        name: 'context',
+        message,
+        choices: [...names.map((name) => ({ title: name, value: name })), { title: 'Create new context', value: '__create__' }]
+    });
+    if (!result.context)
+        return null;
+    if (result.context !== '__create__')
+        return String(result.context);
+    const answer = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Context name:',
+        validate: (value) => {
+            try {
+                normalizePascalName(value);
+                return true;
+            }
+            catch (error) {
+                return error.message;
+            }
+        }
+    });
+    return answer.name ? ensureContextStructure(String(answer.name)) : null;
+}
+/** null means cancelled; undefined means the flat Presentation layout. */
+export async function selectPresentationWorkspace(message = 'Select presentation workspace:') {
+    const workspaces = await discoverPresentationWorkspaces();
+    if (!workspaces.length)
+        return undefined;
+    await ensurePresentationStructure(SHARED_WORKSPACE);
+    if (!workspaces.includes(SHARED_WORKSPACE))
+        workspaces.push(SHARED_WORKSPACE);
+    const answer = await prompts({
+        type: 'select',
+        name: 'workspace',
+        message,
+        choices: workspaces.sort().map((name) => ({ title: name, value: name }))
+    });
+    return answer.workspace ? String(answer.workspace) : null;
+}
+export async function selectWorkspace() {
+    const name = await selectPresentationWorkspace();
+    if (name === null)
+        return null;
+    return { name: name ?? '', path: getPresentationPath(name), alias: getPresentationImportPath(name) };
+}
+export async function selectScope(workspace) {
+    const root = path.join(workspace.path, 'Scopes');
+    const scopes = (await directories(root)).filter((name) => /^[A-Z][A-Za-z0-9]*$/.test(name));
+    const answer = await prompts({
+        type: 'select',
+        name: 'scope',
+        message: 'Select scope:',
+        choices: [...scopes.map((name) => ({ title: name, value: name })), { title: 'Create new scope', value: '__create__' }]
+    });
+    if (!answer.scope)
+        return null;
+    if (answer.scope !== '__create__')
+        return String(answer.scope);
+    const created = await prompts({
+        type: 'text',
+        name: 'name',
+        message: 'Scope name:',
+        validate: (value) => {
+            try {
+                normalizePascalName(value);
+                return true;
+            }
+            catch (error) {
+                return error.message;
+            }
+        }
+    });
+    if (!created.name)
+        return null;
+    const name = normalizePascalName(String(created.name));
+    await fs.mkdir(path.join(root, name), { recursive: true });
+    return name;
+}

package/src/utils/contextUtils.js

@@ -1,73 +1,40 @@
-import fs from 'fs/promises';
-import path from 'path';
-import prompts from 'prompts';
-import { loadUserConfig } from './loadConfig.js';
-const APP_PATH = path.join(process.cwd(), 'src/app');
-function normalizeContextNames(rawContexts) {
-	if (!Array.isArray(rawContexts)) return [];
-	return rawContexts
-		.map((item) => {
-			if (typeof item === 'string') {
-				return item.trim();
-			}
-			if (!item || typeof item !== 'object') return '';
-			return String(item.name ?? '').trim();
-		})
-		.filter(Boolean);
-}
-export async function selectContext(message = 'Select context:') {
-	const config = await loadUserConfig();
-	const contexts = normalizeContextNames(config.contexts);
-	const { context } = await prompts({
-		type: 'select',
-		name: 'context',
-		message,
-		choices: contexts.map((c) => ({ title: c, value: c }))
-	});
-	return context ? String(context) : null;
-}
-export function getContextPath(context) {
-	return path.join(APP_PATH, context, 'layers');
-}
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getPlatformPath, normalizePascalName } from './architecture.js';
+export { getContextPath, selectContext, selectPresentationWorkspace, discoverContexts, discoverPresentationWorkspaces, normalizePascalName } from './architecture.js';
 export async function getAvailableFiles(dir, pattern = '.ts') {
-	try {
-		const files = await fs.readdir(dir);
-		return files.filter((f) => f.endsWith(pattern) && f !== 'index.ts').map((f) => f.replace(pattern, ''));
-	} catch {
-		return [];
-	}
-}
-export async function getApplicationProviderServices(context) {
-	const contextPath = getContextPath(context);
-	const providerPath = path.join(contextPath, 'application/providers/ApplicationProvider.ts');
-	try {
-		const content = await fs.readFile(providerPath, 'utf-8');
-		// Extract service names from ApplicationProvider
-		const serviceRegex = /(\w+Service):\s*\(/g;
-		const services = [];
-		let match;
-		while ((match = serviceRegex.exec(content)) !== null) {
-			const serviceName = match[1];
-			if (serviceName) services.push(serviceName);
-		}
-		return services;
-	} catch {
-		return [];
-	}
+    try {
+        return (await fs.readdir(dir))
+            .filter((file) => file.endsWith(pattern) && file !== 'index.ts')
+            .map((file) => file.slice(0, -pattern.length));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+export async function getApplicationProviderServices() {
+    try {
+        const content = await fs.readFile(path.join(getPlatformPath(), 'Foundation/DI/ApplicationProvider.ts'), 'utf8');
+        return Array.from(content.matchAll(/(\w+Service):\s*\(/g), (match) => match[1]);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
 }
 export function toPascalCase(str) {
-	return str
-		.split(/[-_\s]+/)
-		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-		.join('');
+    return str.trim() ? normalizePascalName(str) : '';
 }
 export function toCamelCase(str) {
-	const pascal = toPascalCase(str);
-	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
 }
 export function toKebabCase(str) {
-	return str
-		.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-		.replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
-		.toLowerCase();
+    return str
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase();
 }

package/src/utils/fileUtils.js

@@ -1,60 +1,79 @@
 import fs from 'fs/promises';
 import path from 'path';
 export async function writeIfNotExists(filepath, content) {
-	try {
-		await fs.access(filepath);
-		console.log(`⚠️  Skip existing: ${filepath}`);
-		return false;
-	} catch {
-		await fs.mkdir(path.dirname(filepath), { recursive: true });
-		await fs.writeFile(filepath, content, 'utf-8');
-		console.log(`✅ Created: ${filepath}`);
-		return true;
-	}
+    await fs.mkdir(path.dirname(filepath), { recursive: true });
+    try {
+        await fs.writeFile(filepath, content, { encoding: 'utf8', flag: 'wx' });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        console.log(`Skip existing: ${filepath}`);
+        return false;
+    }
+    console.log(`Created: ${filepath}`);
+    return true;
+}
+export async function appendBarrelExports(filepath, sources) {
+    let content = '';
+    try {
+        content = await fs.readFile(filepath, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const additions = sources
+        .filter((source) => !content.includes("from '" + source + "'") && !content.includes('from "' + source + '"'))
+        .map((source) => 'export * from ' + JSON.stringify(source) + ';');
+    if (!additions.length && content.trim())
+        return;
+    await fs.mkdir(path.dirname(filepath), { recursive: true });
+    await fs.writeFile(filepath, content + (content && !content.endsWith('\n') ? '\n' : '') + (additions.length ? additions.join('\n') : 'export {};') + '\n');
 }
 export async function updateIndexTs(dir, filePattern = '.ts', ignore = ['index.ts']) {
-	try {
-		const files = (await fs.readdir(dir)).filter((f) => f.endsWith(filePattern) && !ignore.includes(f));
-		const content = files.map((f) => `export * from './${f.replace('.ts', '')}';`).join('\n') + '\n';
-		await fs.writeFile(path.join(dir, 'index.ts'), content, 'utf-8');
-	} catch {
-		// Directory doesn't exist yet
-	}
+    const files = (await fs.readdir(dir))
+        .filter((file) => file.endsWith(filePattern) && !file.endsWith('.d.ts') && !ignore.includes(file))
+        .sort();
+    await appendBarrelExports(path.join(dir, 'index.ts'), files.map((file) => './' + file.slice(0, -filePattern.length)));
 }
 export async function ensureIndexExports(layerPath) {
-	try {
-		const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
-		const exportLines = subdirs.filter((d) => d.isDirectory()).map((d) => `export * from './${d.name}';`);
-		if (exportLines.length > 0) {
-			await fs.writeFile(path.join(layerPath, 'index.ts'), exportLines.join('\n') + '\n', 'utf-8');
-		}
-	} catch {
-		// Directory doesn't exist
-	}
+    try {
+        const subdirs = await fs.readdir(layerPath, { withFileTypes: true });
+        const exportLines = subdirs.filter((d) => d.isDirectory()).map((d) => `export * from './${d.name}';`);
+        if (exportLines.length > 0) {
+            await fs.writeFile(path.join(layerPath, 'index.ts'), exportLines.join('\n') + '\n', 'utf-8');
+        }
+    }
+    catch {
+        // Directory doesn't exist
+    }
 }
 export async function injectIntoFile(filepath, searchPattern, newContent, position = 'after') {
-	try {
-		let content = await fs.readFile(filepath, 'utf-8');
-		const index = content.indexOf(searchPattern);
-		if (index === -1) {
-			console.warn(`Pattern not found in ${filepath}`);
-			return false;
-		}
-		if (content.includes(newContent.trim())) {
-			console.log(`Content already exists in ${filepath}`);
-			return false;
-		}
-		if (position === 'after') {
-			const insertIndex = index + searchPattern.length;
-			content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
-		} else {
-			content = content.slice(0, index) + newContent + '\n' + content.slice(index);
-		}
-		await fs.writeFile(filepath, content, 'utf-8');
-		console.log(`✅ Updated: ${filepath}`);
-		return true;
-	} catch (error) {
-		console.error(`Failed to update ${filepath}:`, error instanceof Error ? error.message : String(error));
-		return false;
-	}
+    try {
+        let content = await fs.readFile(filepath, 'utf-8');
+        const index = content.indexOf(searchPattern);
+        if (index === -1) {
+            console.warn(`Pattern not found in ${filepath}`);
+            return false;
+        }
+        if (content.includes(newContent.trim())) {
+            console.log(`Content already exists in ${filepath}`);
+            return false;
+        }
+        if (position === 'after') {
+            const insertIndex = index + searchPattern.length;
+            content = content.slice(0, insertIndex) + '\n' + newContent + content.slice(insertIndex);
+        }
+        else {
+            content = content.slice(0, index) + newContent + '\n' + content.slice(index);
+        }
+        await fs.writeFile(filepath, content, 'utf-8');
+        console.log(`✅ Updated: ${filepath}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to update ${filepath}:`, error instanceof Error ? error.message : String(error));
+        return false;
+    }
 }