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

package/src/generate/ui/generateWidget.js

@@ -2,58 +2,38 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import prompts from 'prompts';
 import { toPascalCase } from '../../utils/contextUtils.js';
-import { normalizeContexts } from '../../init/initAliases.js';
-import { loadUserConfig } from '../../utils/loadConfig.js';
+import { selectWorkspace } from '../../utils/architecture.js';
 import { writeIfNotExists } from '../../utils/fileUtils.js';
 const createComponentContent = (propsName) => `<script lang="ts">
-import type { ${propsName} } from './types';
+import type { ${propsName} } from './Types';
 const {}: ${propsName} = $props();
 </script>
 <!--Your HTML here-->
 <style lang="scss">
-\t@use './style';
+\t@use './Style';
 </style>
 `;
 const createTypesContent = (propsName) => `export interface ${propsName} {}
 `;
 const createIndexContent = (name) => `export { default as ${name} } from './Component.svelte';
 `;
-const printContextsError = () => {
-	console.error('❌ Cannot generate UI artifact: `contexts` is missing or empty in azure-net.config.ts/js');
-};
-const selectContext = async () => {
-	const config = await loadUserConfig();
-	const contexts = normalizeContexts(config.contexts);
-	if (!contexts.length) return null;
-	const { context } = await prompts({
-		type: 'select',
-		name: 'context',
-		message: 'Select context:',
-		choices: contexts.map((item) => ({ title: item.name, value: item.name })),
-		initial: 0
-	});
-	return context ? String(context) : null;
-};
 export default async function generateWidget() {
-	const context = await selectContext();
-	if (!context) {
-		printContextsError();
-		process.exitCode = 1;
-		return;
-	}
-	const { rawName } = await prompts({
-		type: 'text',
-		name: 'rawName',
-		message: 'Widget name:',
-		validate: (value) => (String(value).trim().length > 0 ? true : 'Name is required')
-	});
-	const name = toPascalCase(String(rawName ?? 'Widget')) || 'Widget';
-	const propsName = `IWidget${name}Props`;
-	const targetDir = path.join(process.cwd(), 'src', 'app', context, 'ui', 'widgets', name);
-	await fs.mkdir(targetDir, { recursive: true });
-	await writeIfNotExists(path.join(targetDir, 'Component.svelte'), createComponentContent(propsName));
-	await writeIfNotExists(path.join(targetDir, 'style.scss'), '');
-	await writeIfNotExists(path.join(targetDir, 'types.ts'), createTypesContent(propsName));
-	await writeIfNotExists(path.join(targetDir, 'index.ts'), createIndexContent(name));
-	console.log(`✅ Widget generated: ${targetDir}`);
+    const workspace = await selectWorkspace();
+    if (!workspace)
+        return;
+    const { rawName } = await prompts({
+        type: 'text',
+        name: 'rawName',
+        message: 'Widget name:',
+        validate: (value) => (String(value).trim().length > 0 ? true : 'Name is required')
+    });
+    const name = toPascalCase(String(rawName ?? 'Widget')) || 'Widget';
+    const propsName = `IWidget${name}Props`;
+    const targetDir = path.join(workspace.path, 'Ui', 'Widgets', name);
+    await fs.mkdir(targetDir, { recursive: true });
+    await writeIfNotExists(path.join(targetDir, 'Component.svelte'), createComponentContent(propsName));
+    await writeIfNotExists(path.join(targetDir, 'Style.scss'), '');
+    await writeIfNotExists(path.join(targetDir, 'Types.ts'), createTypesContent(propsName));
+    await writeIfNotExists(path.join(targetDir, 'index.ts'), createIndexContent(name));
+    console.log(`✅ Widget generated: ${targetDir}`);
 }

package/src/git/commit.js

@@ -0,0 +1,67 @@
+import prompts from 'prompts';
+import { runGit } from './runGit.js';
+export const commitTypes = [
+    { value: 'feat', title: '\u2728 feat: New feature' },
+    { value: 'fix', title: '\ud83d\udc1b fix: Bug fix' },
+    { value: 'docs', title: '\ud83d\udcdd docs: Documentation' },
+    { value: 'style', title: '\ud83c\udfa8 style: Formatting' },
+    { value: 'refactor', title: '\u267b\ufe0f refactor: Code restructuring' },
+    { value: 'perf', title: '\u26a1 perf: Performance' },
+    { value: 'test', title: '\u2705 test: Tests' },
+    { value: 'build', title: '\ud83d\udce6 build: Build system' },
+    { value: 'ci', title: '\ud83d\udc77 ci: Continuous integration' },
+    { value: 'chore', title: '\ud83d\udd27 chore: Maintenance' },
+    { value: 'patch', title: '\ud83d\udd27 patch: Patch release' },
+    { value: 'release', title: '\ud83d\ude80 release: Release' },
+    { value: 'revert', title: '\u23ea revert: Revert changes' }
+];
+export class CommitCancelledError extends Error {
+    constructor() {
+        super('Commit cancelled.');
+    }
+}
+export function validateSubject(value) {
+    if (!value.trim())
+        return 'A subject is required';
+    if (/[\r\n\0]/.test(value))
+        return 'Subject must be a single line';
+    return Array.from(value.trim()).length <= 100 || 'Subject must be at most 100 characters';
+}
+export function formatCommitMessage(answers) {
+    if (!commitTypes.some(({ value }) => value === answers.type))
+        throw new Error('A conventional commit type is required');
+    const validation = validateSubject(answers.subject ?? '');
+    if (validation !== true)
+        throw new Error(validation);
+    const breaking = answers.breaking?.trim();
+    const parts = [
+        `${answers.type}(${commitTypes.find((item) => item.value === answers.type).title.split(' ')[0]})${breaking ? '!' : ''}: ${answers.subject.trim()}`,
+        answers.body?.trim(),
+        breaking ? `BREAKING CHANGE: ${breaking}` : undefined,
+        answers.footer?.trim()
+    ];
+    const message = parts.filter(Boolean).join('\n\n');
+    if (message.includes('\0'))
+        throw new Error('Commit message must not contain null bytes');
+    return message;
+}
+export default async function commit(dependencies = {}) {
+    const prompt = dependencies.prompt ?? prompts;
+    let cancelled = false;
+    const answers = await prompt([
+        { type: 'select', name: 'type', message: 'Commit type', choices: commitTypes },
+        { type: 'text', name: 'subject', message: 'Subject (required, at most 100 characters)', validate: validateSubject },
+        { type: 'text', name: 'body', message: 'Body (optional)' },
+        { type: 'text', name: 'breaking', message: 'Breaking changes (optional)' },
+        { type: 'text', name: 'footer', message: 'Footer / issue references (optional)' }
+    ], {
+        onCancel: () => {
+            cancelled = true;
+            return false;
+        }
+    });
+    if (cancelled || !answers.type || answers.subject === undefined)
+        throw new CommitCancelledError();
+    const message = formatCommitMessage(answers);
+    await (dependencies.git ?? runGit)(['commit', '-m', message]);
+}

package/src/git/push.js

@@ -0,0 +1,19 @@
+import checkProject from '../checks/checkProject.js';
+import { loadUserConfig } from '../utils/loadConfig.js';
+import commit from './commit.js';
+import { runGit } from './runGit.js';
+export default async function push(options = {}, dependencies = {}) {
+    const git = dependencies.git ?? runGit;
+    if (options.check !== false) {
+        const config = await (dependencies.loadConfig ?? loadUserConfig)();
+        if (config.runChecksBeforePush !== false) {
+            await (dependencies.checkProject ?? checkProject)();
+            // checkProject catches failures and communicates them through exitCode.
+            if (process.exitCode && process.exitCode !== '0')
+                throw new Error('Project checks failed; push stopped.');
+        }
+    }
+    await git(['add', '.']);
+    await commit({ prompt: dependencies.prompt, git });
+    await git(['push']);
+}

package/src/git/runGit.js

@@ -0,0 +1,11 @@
+import { spawn } from 'node:child_process';
+export const runGit = (args) => new Promise((resolve, reject) => {
+    const child = spawn('git', args, { stdio: 'inherit', shell: false });
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+        if (code === 0)
+            resolve();
+        else
+            reject(new Error(`git ${args[0]} failed (${signal ? `signal ${signal}` : `exit ${code}`})`));
+    });
+});

package/src/init/initAliases.js

@@ -1,137 +1,21 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { loadUserConfig } from '../utils/loadConfig.js';
-const svelteConfigPath = path.resolve('svelte.config.js');
-function normalizeAliasValue(value, fallbackName) {
-	const raw = String(value ?? '').trim();
-	if (!raw.length) return `$${fallbackName}`;
-	return raw.startsWith('$') ? raw : `$${raw}`;
-}
-export function normalizeContexts(rawContexts) {
-	if (!Array.isArray(rawContexts)) return [];
-	return rawContexts
-		.map((item) => {
-			if (typeof item === 'string') {
-				const name = item.trim();
-				if (!name.length) return null;
-				return { name, alias: `$${name}` };
-			}
-			if (!item || typeof item !== 'object') return null;
-			const name = String(item.name ?? '').trim();
-			if (!name.length) return null;
-			return {
-				name,
-				alias: normalizeAliasValue(item.alias, name)
-			};
-		})
-		.filter((item) => item !== null);
-}
-export function generateAliases(config) {
-	const contexts = normalizeContexts(config.contexts);
-	const entries = [];
-	for (const context of contexts) {
-		entries.push([context.alias, `./src/app/${context.name}`]);
-	}
-	return {
-		contexts,
-		aliases: Object.fromEntries(entries)
-	};
-}
-function parseAliasEntries(aliasBody) {
-	const entryRegex = /(['"`])([^'"`]+)\1\s*:\s*(['"`])([^'"`]+)\3\s*,?/g;
-	const ordered = [];
-	const map = new Map();
-	let match;
-	while ((match = entryRegex.exec(aliasBody)) !== null) {
-		const key = match[2];
-		const value = match[4];
-		if (!key || !value) continue;
-		if (!map.has(key)) {
-			ordered.push(key);
-		}
-		map.set(key, value);
-	}
-	return { ordered, map };
-}
-function buildAliasEntriesString(orderedKeys, map, baseIndent) {
-	if (!orderedKeys.length) return '';
-	return orderedKeys.map((key) => `${baseIndent}'${key}': '${map.get(key) ?? ''}'`).join(',\n');
-}
-function removeAliasEntry(content, alias) {
-	const escapedAlias = alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-	const aliasRegex = new RegExp(`\\n?\\s*['"\`]${escapedAlias}['"\`]\\s*:\\s*['"\`][^'"\`]+['"\`]\\s*,?`, 'g');
-	return content.replace(aliasRegex, '');
-}
-const removeCoreAliasFromAzureNetConfig = async () => {
-	const tsPath = path.resolve('azure-net.config.ts');
-	const jsPath = path.resolve('azure-net.config.js');
-	let filepath = null;
-	try {
-		await fs.access(tsPath);
-		filepath = tsPath;
-	} catch {
-		try {
-			await fs.access(jsPath);
-			filepath = jsPath;
-		} catch {
-			return;
-		}
-	}
-	const content = await fs.readFile(filepath, 'utf-8');
-	if (!/coreAlias\s*:/.test(content)) return;
-	const nextContent = content.replace(/\n?\s*coreAlias\s*:\s*['"`][^'"`]+['"`]\s*,?/m, '').replace(/,\s*\n\s*\}/m, '\n}');
-	await fs.writeFile(filepath, nextContent, 'utf-8');
-};
-export function mergeAliasesInSvelteConfig(content, aliases) {
-	const aliasRegex = /alias\s*:\s*\{([\s\S]*?)\}/m;
-	const aliasMatch = content.match(aliasRegex);
-	if (aliasMatch) {
-		const aliasBody = aliasMatch[1] ?? '';
-		const { ordered, map } = parseAliasEntries(aliasBody);
-		map.delete('$core');
-		for (const [key, value] of Object.entries(aliases)) {
-			if (!map.has(key)) ordered.push(key);
-			map.set(key, value);
-		}
-		const nextOrdered = ordered.filter((key) => key !== '$core');
-		const baseIndentMatch = aliasBody.match(/\n(\s*)['"`]/);
-		const baseIndent = baseIndentMatch?.[1] ?? '\t\t\t';
-		const merged = buildAliasEntriesString(nextOrdered, map, baseIndent);
-		const nextAliasBlock = `alias: {\n${merged}\n\t\t}`;
-		return content.replace(aliasRegex, nextAliasBlock);
-	}
-	const kitRegex = /kit\s*:\s*\{/m;
-	if (kitRegex.test(content)) {
-		const aliasLines = Object.entries(aliases)
-			.map(([key, value]) => `\t\t\t'${key}': '${value}'`)
-			.join(',\n');
-		const aliasBlock = `alias: {\n${aliasLines}\n\t\t},`;
-		return content.replace(kitRegex, `kit: {\n\t\t${aliasBlock}`);
-	}
-	return `${content}\n\n// azure-net aliases\nconst alias = {\n${Object.entries(aliases)
-		.map(([key, value]) => `\t'${key}': '${value}'`)
-		.join(',\n')}\n};\n`;
-}
+import { initializePackageImports } from '../utils/packageImports.js';
+import { ARCHITECTURE_ALIASES, normalizePascalName } from '../utils/architecture.js';
+/** Compatibility only: architecture discovery never reads configured contexts. */
+export function normalizeContexts(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((item) => {
+        const value = typeof item === 'string' ? item : item?.name;
+        if (typeof value !== 'string' || !value.trim())
+            return [];
+        const name = normalizePascalName(value);
+        return [{ name, alias: `#contexts/${name}` }];
+    });
+}
+export function generateAliases() {
+    return { contexts: [], aliases: { ...ARCHITECTURE_ALIASES } };
+}
+export { mergeAliasesInSvelteConfig } from '../utils/legacyAliases.js';
 export default async function initAliases() {
-	const config = await loadUserConfig();
-	const sharedAlias = String(config.sharedAlias ?? '').trim();
-	if (!sharedAlias.length) {
-		console.error('❌ Cannot update aliases: `sharedAlias` is missing in azure-net.config.ts/js.');
-		console.error("Add it first, for example: sharedAlias: '$shared-kernel'");
-		process.exitCode = 1;
-		return;
-	}
-	const generated = generateAliases(config);
-	const aliases = generated.aliases;
-	await removeCoreAliasFromAzureNetConfig();
-	let content;
-	try {
-		content = await fs.readFile(svelteConfigPath, 'utf-8');
-	} catch {
-		console.warn('⚠️ svelte.config.js not found, aliases were not updated');
-		return;
-	}
-	const nextContent = removeAliasEntry(mergeAliasesInSvelteConfig(content, aliases), '$core');
-	await fs.writeFile(svelteConfigPath, nextContent, 'utf-8');
-	console.log('✅ Aliases updated in svelte.config.js');
+    await initializePackageImports();
 }

package/src/init/initEdges.js

@@ -1,59 +1,84 @@
 import fs from 'node:fs/promises';
-import fsSync from 'node:fs';
 import path from 'node:path';
-const EDGES_IMPORT = `import { edgesPlugin } from '@azure-net/kit/edges/plugin';`;
-function resolveViteConfigPath() {
-	const cwd = process.cwd();
-	const candidates = ['vite.config.ts', 'vite.config.js', 'vite.config.mjs', 'vite.config.cjs'].map((filename) => path.join(cwd, filename));
-	for (const filepath of candidates) {
-		if (fsSync.existsSync(filepath)) {
-			return filepath;
-		}
-	}
-	return null;
-}
-function injectEdgesImport(content) {
-	if (content.includes(EDGES_IMPORT)) return content;
-	const svelteImportRegex = /import\s+\{\s*sveltekit\s*\}\s+from\s+['"]@sveltejs\/kit\/vite['"]\s*;?/m;
-	if (svelteImportRegex.test(content)) {
-		return content.replace(svelteImportRegex, (line) => `${line}\n${EDGES_IMPORT}`);
-	}
-	return `${EDGES_IMPORT}\n${content}`;
-}
-function injectEdgesPlugin(content) {
-	if (/edgesPlugin\s*\(\s*\)/.test(content)) return content;
-	const pluginsRegex = /plugins\s*:\s*\[([\s\S]*?)\]/m;
-	const pluginsMatch = content.match(pluginsRegex);
-	if (!pluginsMatch) {
-		throw new Error('plugins array was not found in vite.config');
-	}
-	const pluginsBody = pluginsMatch[1] ?? '';
-	let nextPluginsBody = pluginsBody;
-	if (/sveltekit\s*\(\s*\)/.test(pluginsBody)) {
-		nextPluginsBody = pluginsBody.replace(/sveltekit\s*\(\s*\)\s*,?/, (matched) => {
-			const hasComma = matched.trim().endsWith(',');
-			return hasComma ? `${matched} edgesPlugin(),` : `${matched}, edgesPlugin()`;
-		});
-	} else {
-		const trimmed = pluginsBody.trim();
-		if (!trimmed.length) {
-			nextPluginsBody = 'edgesPlugin()';
-		} else {
-			const withComma = /\s*,\s*$/.test(pluginsBody) ? pluginsBody : `${pluginsBody},`;
-			nextPluginsBody = `${withComma} edgesPlugin()`;
-		}
-	}
-	return content.replace(pluginsRegex, `plugins: [${nextPluginsBody}]`);
+import ts from 'typescript';
+import { VITE_CONFIGS, formatConfig, enableHydratable } from '../utils/viteConfig.js';
+export function configureAzureNetPlugin(content) {
+    const source = ts.createSourceFile('vite.config.ts', content, ts.ScriptTarget.Latest, true);
+    const edits = [];
+    let pluginName = 'AzureNetPlugin';
+    let imported = false;
+    const legacyNames = new Set();
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        if (statement.moduleSpecifier.text === '@azure-net/kit/plugin') {
+            for (const item of bindings.elements)
+                if ((item.propertyName?.text ?? item.name.text) === 'AzureNetPlugin') {
+                    pluginName = item.name.text;
+                    imported = true;
+                }
+        }
+        if (statement.moduleSpecifier.text === '@azure-net/kit/edges/plugin') {
+            for (const item of bindings.elements)
+                if ((item.propertyName?.text ?? item.name.text) === 'edgesPlugin')
+                    legacyNames.add(item.name.text);
+            if (bindings.elements.some((item) => (item.propertyName?.text ?? item.name.text) !== 'edgesPlugin'))
+                throw new Error('Remove unsupported legacy edges/plugin imports from Vite config first.');
+            edits.push({ start: statement.getStart(source), end: statement.end, text: '' });
+        }
+    }
+    let plugins;
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) &&
+            (ts.isIdentifier(node.name) || ts.isStringLiteral(node.name)) &&
+            node.name.text === 'plugins' &&
+            ts.isArrayLiteralExpression(node.initializer))
+            plugins ??= node.initializer;
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    if (!plugins)
+        throw new Error('Cannot safely configure AzureNetPlugin: use a literal plugins array in vite.config.');
+    const existing = plugins.elements.some((element) => ts.isCallExpression(element) && ts.isIdentifier(element.expression) && element.expression.text === pluginName);
+    let replacedLegacy = false;
+    for (const element of plugins.elements) {
+        if (!ts.isCallExpression(element) || !ts.isIdentifier(element.expression) || !legacyNames.has(element.expression.text))
+            continue;
+        if (existing || replacedLegacy)
+            throw new Error('Both legacy and AzureNet plugins are configured. Remove the legacy plugin call first.');
+        edits.push({ start: element.getStart(source), end: element.end, text: `${pluginName}()` });
+        replacedLegacy = true;
+    }
+    if (!existing && !replacedLegacy) {
+        const last = plugins.elements.at(-1);
+        edits.push({ start: plugins.end - 1, end: plugins.end - 1, text: `\n${pluginName}()\n` });
+        if (last && !plugins.elements.hasTrailingComma)
+            edits.push({ start: last.end, end: last.end, text: ',' });
+    }
+    for (const edit of edits.sort((a, b) => b.start - a.start))
+        content = content.slice(0, edit.start) + edit.text + content.slice(edit.end);
+    if (!imported)
+        content = `import { AzureNetPlugin } from '@azure-net/kit/plugin';\n${content}`;
+    return enableHydratable(content);
 }
 export default async function initEdges() {
-	const viteConfigPath = resolveViteConfigPath();
-	if (!viteConfigPath) {
-		console.error('❌ vite.config.(ts|js|mjs|cjs) was not found');
-		return;
-	}
-	let content = await fs.readFile(viteConfigPath, 'utf-8');
-	content = injectEdgesImport(content);
-	content = injectEdgesPlugin(content);
-	await fs.writeFile(viteConfigPath, content, 'utf-8');
-	console.log(`✅ Edges plugin initialized in ${path.basename(viteConfigPath)}`);
+    for (const name of VITE_CONFIGS) {
+        const file = path.resolve(name);
+        let content;
+        try {
+            content = await fs.readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        await fs.writeFile(file, await formatConfig(configureAzureNetPlugin(content), file));
+        console.log(`AzureNetPlugin configured in ${name}`);
+        return;
+    }
+    throw new Error('vite.config.(ts|js|mjs) was not found. Initialize a SvelteKit project first.');
 }