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

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;
+    }
 }

package/src/utils/flattenConfig.js

@@ -0,0 +1,38 @@
+import ts from 'typescript';
+/** Flatten literal-only spreads without evaluating user configuration or duplicating effects. */
+export function flattenConfigLiterals(content) {
+    const source = ts.createSourceFile('azure-net.config.ts', content, ts.ScriptTarget.Latest, true);
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported)
+        return content;
+    const unwrap = (node) => (ts.isParenthesizedExpression(node) ? unwrap(node.expression) : node);
+    const root = unwrap(exported.expression);
+    if (!ts.isObjectLiteralExpression(root))
+        return content;
+    let changed = false;
+    const flatten = (object) => object.properties.flatMap((property) => {
+        if (ts.isSpreadAssignment(property)) {
+            const value = unwrap(property.expression);
+            if (ts.isObjectLiteralExpression(value) &&
+                value.properties.every((p) => !ts.isGetAccessorDeclaration(p) &&
+                    !ts.isSetAccessorDeclaration(p) &&
+                    !(p.name && p.name.getText(source).replace(/['"]/g, '') === '__proto__'))) {
+                changed = true;
+                return flatten(value);
+            }
+        }
+        return [property];
+    });
+    const properties = flatten(root);
+    if (!changed)
+        return content;
+    const names = properties
+        .filter((p) => p.name && !ts.isComputedPropertyName(p.name))
+        .map((p) => p.name.getText(source).replace(/['"]/g, ''));
+    // Duplicate literal keys can produce invalid TypeScript; retain the original spread semantics.
+    if (new Set(names).size !== names.length)
+        return content;
+    const updated = ts.factory.updateObjectLiteralExpression(root, properties);
+    const printed = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed }).printNode(ts.EmitHint.Expression, updated, source);
+    return content.slice(0, root.getStart(source)) + printed + content.slice(root.end);
+}

package/src/utils/legacyAliases.js

@@ -0,0 +1,75 @@
+import ts from 'typescript';
+export function mergeAliasesInSvelteConfig(content, aliases) {
+    const source = ts.createSourceFile('svelte.config.js', content, ts.ScriptTarget.Latest, true, ts.ScriptKind.JS);
+    function resolve(expression, seen = new Set()) {
+        if (ts.isObjectLiteralExpression(expression))
+            return expression;
+        if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression))
+            return resolve(expression.expression, seen);
+        if (ts.isIdentifier(expression) && !seen.has(expression.text)) {
+            seen.add(expression.text);
+            for (const statement of source.statements)
+                if (ts.isVariableStatement(statement)) {
+                    for (const declaration of statement.declarationList.declarations)
+                        if (ts.isIdentifier(declaration.name) && declaration.name.text === expression.text && declaration.initializer)
+                            return resolve(declaration.initializer, seen);
+                }
+        }
+        throw new Error('Cannot safely merge Svelte aliases: use an object literal or a local object variable for the config and kit.');
+    }
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported)
+        throw new Error('Cannot safely merge Svelte aliases: no default export found.');
+    const root = resolve(exported.expression);
+    const property = (object, name) => [...object.properties]
+        .reverse()
+        .find((entry) => entry.name && (ts.isIdentifier(entry.name) || ts.isStringLiteral(entry.name)) && entry.name.text === name);
+    const value = (entry) => {
+        if (ts.isPropertyAssignment(entry))
+            return entry.initializer;
+        if (ts.isShorthandPropertyAssignment(entry))
+            return entry.name;
+        throw new Error('Cannot safely merge Svelte aliases: unsupported property declaration.');
+    };
+    const insert = (object, text) => {
+        const last = object.properties.at(-1);
+        const comma = last && !object.properties.hasTrailingComma ? ',' : '';
+        // Insert the separator before any trailing line comment.
+        let next = content.slice(0, object.end - 1) + `\n${text}\n` + content.slice(object.end - 1);
+        if (last && comma)
+            next = next.slice(0, last.end) + comma + next.slice(last.end);
+        return next;
+    };
+    const entries = Object.entries(aliases)
+        .map(([key, target]) => `${JSON.stringify(key)}: ${JSON.stringify(target)}`)
+        .join(',\n');
+    const kit = property(root, 'kit');
+    if (!kit)
+        return insert(root, `kit: { alias: { ${entries} } }`);
+    const kitObject = resolve(value(kit));
+    const alias = property(kitObject, 'alias');
+    if (!alias)
+        return insert(kitObject, `alias: { ${entries} }`);
+    const expression = value(alias);
+    if (ts.isObjectLiteralExpression(expression)) {
+        const missing = Object.entries(aliases).filter(([key, target]) => {
+            const entry = property(expression, key);
+            if (!entry || !ts.isPropertyAssignment(entry) || !ts.isStringLiteral(entry.initializer) || entry.initializer.text !== target)
+                return true;
+            // Later spreads or computed keys can override an otherwise correct entry.
+            return expression.properties
+                .slice(expression.properties.indexOf(entry) + 1)
+                .some((later) => ts.isSpreadAssignment(later) || (later.name && ts.isComputedPropertyName(later.name)));
+        });
+        if (!missing.length)
+            return content;
+        if (missing.every(([key]) => !property(expression, key))) {
+            return insert(expression, missing.map(([key, target]) => `${JSON.stringify(key)}: ${JSON.stringify(target)}`).join(',\n'));
+        }
+    }
+    // Preserve every user expression, spread and comment; fixed architecture aliases win.
+    const replacement = `{ ...(${expression.getText(source)}), ${entries} }`;
+    if (ts.isShorthandPropertyAssignment(alias))
+        return content.slice(0, alias.getStart(source)) + `alias: ${replacement}` + content.slice(alias.end);
+    return content.slice(0, expression.getStart(source)) + replacement + content.slice(expression.end);
+}

package/src/utils/loadConfig.js

@@ -1,46 +1,82 @@
 import fs from 'node:fs/promises';
 import fsSync from 'node:fs';
 import path from 'node:path';
-const DEFAULT_CONFIG = {
-	contexts: [],
-	defaultContext: 'web'
-};
-function toObjectFromDefaultExport(content) {
-	const source = String(content ?? '').trim();
-	if (!source.length) return {};
-	const replacedExport = source.replace(/^\s*export\s+default\s+/m, 'return ');
-	if (replacedExport === source) return {};
-	const withSemicolon = /;\s*$/.test(replacedExport) ? replacedExport : `${replacedExport};`;
-	try {
-		return new Function(withSemicolon)() ?? {};
-	} catch {
-		return {};
-	}
-}
+import { createRequire } from 'node:module';
+import ts from 'typescript';
+import { flattenConfigLiterals } from './flattenConfig.js';
 export function resolveConfigFile(cwd = process.cwd()) {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-	if (fsSync.existsSync(tsPath)) {
-		return { exists: true, filepath: tsPath, type: 'ts' };
-	}
-	if (fsSync.existsSync(jsPath)) {
-		return { exists: true, filepath: jsPath, type: 'js' };
-	}
-	return { exists: false, filepath: tsPath, type: 'ts' };
+    for (const type of ['ts', 'js']) {
+        const filepath = path.join(cwd, `azure-net.config.${type}`);
+        if (fsSync.existsSync(filepath))
+            return { exists: true, filepath, type };
+    }
+    return { exists: false, filepath: path.join(cwd, 'azure-net.config.ts'), type: 'ts' };
+}
+export async function loadUserConfig(cwd = process.cwd()) {
+    const { exists, filepath } = resolveConfigFile(cwd);
+    if (!exists)
+        return {};
+    try {
+        const source = await fs.readFile(filepath, 'utf8');
+        const result = ts.transpileModule(source, {
+            fileName: filepath,
+            reportDiagnostics: true,
+            compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.CommonJS, esModuleInterop: true }
+        });
+        const errors = result.diagnostics?.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error) ?? [];
+        if (errors.length)
+            throw new Error(errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, '\n')).join('\n'));
+        const module = { exports: {} };
+        new Function('module', 'exports', 'require', '__filename', '__dirname', result.outputText)(module, module.exports, createRequire(filepath), filepath, path.dirname(filepath));
+        const config = module.exports.default;
+        if (!config || typeof config !== 'object' || Array.isArray(config))
+            throw new Error('Expected a default-exported configuration object.');
+        const parsed = config;
+        if (parsed.presentationWorkspaces !== undefined &&
+            (!Array.isArray(parsed.presentationWorkspaces) ||
+                parsed.presentationWorkspaces.some((name) => typeof name !== 'string' || !/^[A-Za-z][A-Za-z0-9 _-]*$/.test(name.trim()))))
+            throw new Error('presentationWorkspaces must be an array of valid workspace names.');
+        if (parsed.runChecksBeforePush !== undefined && typeof parsed.runChecksBeforePush !== 'boolean')
+            throw new Error('runChecksBeforePush must be a boolean.');
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Unable to load ${filepath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
 }
-export async function loadUserConfig() {
-	const { exists, filepath } = resolveConfigFile();
-	if (!exists) {
-		return { ...DEFAULT_CONFIG };
-	}
-	try {
-		const content = await fs.readFile(filepath, 'utf-8');
-		const parsed = toObjectFromDefaultExport(content);
-		if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-			return { ...DEFAULT_CONFIG };
-		}
-		return { ...DEFAULT_CONFIG, ...parsed };
-	} catch {
-		return { ...DEFAULT_CONFIG };
-	}
+/** Add the default without rewriting or dropping legacy/user configuration. */
+export async function initializeConfigDefaults(cwd = process.cwd()) {
+    const existing = resolveConfigFile(cwd);
+    if (existing.exists) {
+        const original = await fs.readFile(existing.filepath, 'utf8');
+        const flattened = flattenConfigLiterals(original);
+        if (flattened !== original)
+            await fs.writeFile(existing.filepath, flattened);
+    }
+    const config = await loadUserConfig(cwd);
+    if (config.runChecksBeforePush !== undefined)
+        return;
+    const resolved = resolveConfigFile(cwd);
+    if (!resolved.exists) {
+        await fs.writeFile(resolved.filepath, 'export default {\n\trunChecksBeforePush: true\n};\n', { flag: 'wx' });
+        return;
+    }
+    const content = await fs.readFile(resolved.filepath, 'utf8');
+    const source = ts.createSourceFile(resolved.filepath, content, ts.ScriptTarget.Latest, true);
+    const exported = source.statements.find(ts.isExportAssignment);
+    if (!exported || exported.isExportEquals)
+        throw new Error(`Cannot initialize ${resolved.filepath}: expected a default export.`);
+    const expression = exported.expression;
+    let nextContent;
+    if (ts.isObjectLiteralExpression(expression)) {
+        const last = expression.properties.at(-1);
+        nextContent = content.slice(0, expression.end - 1) + '\n\trunChecksBeforePush: true\n' + content.slice(expression.end - 1);
+        if (last && !expression.properties.hasTrailingComma)
+            nextContent = nextContent.slice(0, last.end) + ',' + nextContent.slice(last.end);
+    }
+    else {
+        const replacement = `{ ...(${expression.getText(source)}), runChecksBeforePush: true }`;
+        nextContent = content.slice(0, expression.getStart(source)) + replacement + content.slice(expression.end);
+    }
+    await fs.writeFile(resolved.filepath, nextContent, 'utf8');
 }