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

package/src/migrate/presenters.js

@@ -0,0 +1,265 @@
+import ts from 'typescript';
+import { parseSource } from '../checks/architecture.js';
+const printer = ts.createPrinter();
+const helperNames = new Set(['createAsyncAction', 'createAsyncResource']);
+const apply = (input, edits) => {
+    for (const edit of edits.sort((a, b) => b.start - a.start))
+        input = input.slice(0, edit.start) + edit.text + input.slice(edit.end);
+    return input;
+};
+export function migrateAsyncHelpers(input, file) {
+    const source = parseSource(input, file);
+    const edits = [];
+    const factories = new Set();
+    const occupied = new Set();
+    const collect = (node) => {
+        if (ts.isIdentifier(node))
+            occupied.add(node.text);
+        ts.forEachChild(node, collect);
+    };
+    collect(source);
+    const unique = (base) => {
+        let name = base;
+        while (occupied.has(name))
+            name += '_';
+        occupied.add(name);
+        return name;
+    };
+    const action = unique('kitCreateAsyncAction');
+    const resource = unique('kitCreateAsyncResource');
+    let helpersImported = false;
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== '@azure-net/kit/delivery')
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (!bindings || !ts.isNamedImports(bindings))
+            continue;
+        const kept = bindings.elements.filter((entry) => {
+            if ((entry.propertyName ?? entry.name).text !== 'createAsyncHelpers')
+                return true;
+            factories.add(entry.name.text);
+            return false;
+        });
+        if (kept.length === bindings.elements.length)
+            continue;
+        const extra = helpersImported ? [] : [`createAsyncAction as ${action}`, `createAsyncResource as ${resource}`];
+        helpersImported = true;
+        edits.push({
+            start: bindings.getStart(source),
+            end: bindings.end,
+            text: `{ ${[...kept.map((e) => e.getText(source)), ...extra].join(', ')} }`
+        });
+    }
+    if (!factories.size)
+        return input;
+    const validate = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && factories.has(node.text)) {
+            if (!ts.isCallExpression(node.parent) || node.parent.expression !== node || node.parent.arguments.length) {
+                throw new Error(`${node.text} is not a direct zero-argument call`);
+            }
+        }
+        ts.forEachChild(node, validate);
+    };
+    validate(source);
+    const specialize = (name, errorType) => errorType
+        ? `${name} as <Res = never, Req = never>(...args: Parameters<typeof ${name}<Res, Req, ${errorType}>>) => ReturnType<typeof ${name}<Res, Req, ${errorType}>>`
+        : name;
+    const visit = (node) => {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && factories.has(node.expression.text) && !node.arguments.length) {
+            const errorType = node.typeArguments?.[0]?.getText(source);
+            edits.push({
+                start: node.getStart(source),
+                end: node.end,
+                text: `({ createAsyncAction: ${specialize(action, errorType)}, createAsyncResource: ${specialize(resource, errorType)} })`
+            });
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return apply(input, edits);
+}
+/** Upgrade only recognized factories; arbitrary injected dependencies require a human decision. */
+export function migratePresenterSource(input, file, factories) {
+    const source = ts.createSourceFile(file, input, ts.ScriptTarget.Latest, true);
+    const edits = [];
+    const converted = new Map();
+    const issues = [];
+    const imports = new Set();
+    const removedFactories = new Set();
+    const existingImports = new Set();
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) ||
+            !ts.isStringLiteral(statement.moduleSpecifier) ||
+            statement.moduleSpecifier.text !== '@azure-net/kit/delivery' ||
+            statement.importClause?.isTypeOnly)
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings && ts.isNamedImports(bindings))
+            for (const entry of bindings.elements) {
+                if (!entry.isTypeOnly)
+                    existingImports.add(entry.propertyName ? `${entry.propertyName.text} as ${entry.name.text}` : entry.name.text);
+            }
+    }
+    for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
+            continue;
+        const declaration = statement.declarationList.declarations[0];
+        const call = declaration.initializer;
+        if (!ts.isIdentifier(declaration.name) ||
+            !call ||
+            !ts.isCallExpression(call) ||
+            !ts.isIdentifier(call.expression) ||
+            !factories.has(call.expression.text))
+            continue;
+        const name = declaration.name.text;
+        try {
+            const callback = call.arguments.find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+            if (!callback ||
+                (!ts.isArrowFunction(callback) && !ts.isFunctionExpression(callback)) ||
+                !ts.isBlock(callback.body) ||
+                callback.typeParameters ||
+                callback.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword))
+                throw new Error('Expected a synchronous block factory');
+            if (call.arguments.length !== 2 || !ts.isStringLiteral(call.arguments[0]))
+                throw new Error('Custom factory arguments need manual review');
+            const requestedImports = new Set();
+            if (callback.parameters.length) {
+                const param = callback.parameters[0];
+                if (callback.parameters.length !== 1 || !ts.isObjectBindingPattern(param.name) || param.initializer)
+                    throw new Error('Unsupported injected dependencies');
+                for (const binding of param.name.elements) {
+                    const original = (binding.propertyName ?? binding.name).getText(source);
+                    if (!helperNames.has(original) || !ts.isIdentifier(binding.name) || binding.initializer || binding.dotDotDotToken)
+                        throw new Error(`Injected dependency ${original} requires manual conversion`);
+                    requestedImports.add(original === binding.name.text ? original : `${original} as ${binding.name.text}`);
+                }
+            }
+            const statements = [...callback.body.statements];
+            let usesThis = false;
+            const findThis = (node) => {
+                if (node.kind === ts.SyntaxKind.ThisKeyword)
+                    usesThis = true;
+                ts.forEachChild(node, findThis);
+            };
+            findThis(callback.body);
+            if (usesThis)
+                throw new Error('Explicit this binding requires manual conversion');
+            const result = statements.at(-1);
+            if (!result || !ts.isReturnStatement(result) || !result.expression || !ts.isObjectLiteralExpression(result.expression))
+                throw new Error('Expected a final object-literal return');
+            const keys = result.expression.properties.map((prop) => {
+                if (!prop.name || !ts.isIdentifier(prop.name))
+                    throw new Error('Spread/computed return keys require manual conversion');
+                if (prop.name.text === 'constructor')
+                    throw new Error('Reserved presenter member');
+                return prop.name.text;
+            });
+            if (new Set(keys).size !== keys.length)
+                throw new Error('Duplicate return keys');
+            const parameters = [];
+            const argumentsList = [];
+            const registrations = [];
+            const body = statements.filter((stmt) => {
+                if (!ts.isVariableStatement(stmt) || stmt.declarationList.declarations.length !== 1)
+                    return true;
+                const binding = stmt.declarationList.declarations[0];
+                const value = binding.initializer;
+                if (!ts.isObjectBindingPattern(binding.name) ||
+                    !value ||
+                    !ts.isCallExpression(value) ||
+                    !ts.isIdentifier(value.expression) ||
+                    !/Provider$/.test(value.expression.text))
+                    return true;
+                if (value.arguments.length)
+                    throw new Error('Provider arguments require manual conversion');
+                for (const entry of binding.name.elements) {
+                    if (!ts.isIdentifier(entry.name) || entry.dotDotDotToken || entry.initializer)
+                        throw new Error('Unsupported provider destructuring');
+                    const key = (entry.propertyName ?? entry.name).getText(source).replace(/^['"]|['"]$/g, '');
+                    parameters.push(`${entry.name.text}: ReturnType<typeof ${value.expression.text}>[${JSON.stringify(key)}]`);
+                    argumentsList.push(entry.name.text);
+                }
+                registrations.push(stmt.getText(source));
+                return false;
+            });
+            // Keep lexical state and callbacks intact rather than guessing this-binding rewrites.
+            const setup = `create${name}State`;
+            if (new RegExp(`\\b(?:use${name}|${setup})\\b`).test(input))
+                throw new Error('Generated declaration name already exists');
+            const javascript = file.endsWith('.js');
+            const parameterList = (javascript ? argumentsList : parameters).join(', ');
+            const members = result.expression.properties.map((property, index) => {
+                const key = keys[index];
+                return (`get ${key}() { return this.#state.${key}; }` +
+                    (ts.isGetAccessorDeclaration(property) || callback.type
+                        ? ''
+                        : `\nset ${key}(value${javascript ? '' : `: ReturnType<typeof ${setup}>[${JSON.stringify(key)}]`}) { this.#state.${key} = value; }`));
+            });
+            const text = `function ${setup}(${parameterList})${callback.type ? ': ' + callback.type.getText(source) : ''} {\n${body.map((stmt) => stmt.getText(source)).join('\n')}\n}\n\nexport class ${name} {\n#state${javascript ? '' : `: ReturnType<typeof ${setup}>`};\nconstructor(${parameterList}) { this.#state = ${setup}(${argumentsList.join(', ')}); }\n${members.join('\n')}\n}\n\nexport const use${name} = RegisterProvider(() => {\n${registrations.join('\n')}\nreturn new ${name}(${argumentsList.join(', ')});\n}, 'scoped');`;
+            edits.push({ start: statement.getStart(source), end: statement.end, text });
+            converted.set(name, `use${name}`);
+            removedFactories.add(call.expression.text);
+            imports.add('RegisterProvider');
+            for (const helper of requestedImports)
+                imports.add(helper);
+        }
+        catch (error) {
+            issues.push(`${name}: ${String(error)}. Original presenter retained.`);
+        }
+    }
+    let output = apply(input, edits);
+    if (converted.size) {
+        const parsed = ts.createSourceFile(file, output, ts.ScriptTarget.Latest, true);
+        const importEdits = [];
+        for (const statement of parsed.statements) {
+            if (!ts.isImportDeclaration(statement) ||
+                !statement.importClause?.namedBindings ||
+                !ts.isNamedImports(statement.importClause.namedBindings))
+                continue;
+            const bindings = statement.importClause.namedBindings;
+            const kept = bindings.elements.filter((entry) => {
+                if (!removedFactories.has(entry.name.text))
+                    return true;
+                let used = false;
+                const visit = (node) => {
+                    if (ts.isImportDeclaration(node))
+                        return;
+                    if (ts.isIdentifier(node) && node.text === entry.name.text)
+                        used = true;
+                    ts.forEachChild(node, visit);
+                };
+                visit(parsed);
+                return used;
+            });
+            if (kept.length === bindings.elements.length)
+                continue;
+            const updated = kept.length || statement.importClause.name
+                ? ts.factory.updateImportDeclaration(statement, statement.modifiers, ts.factory.updateImportClause(statement.importClause, statement.importClause.isTypeOnly, statement.importClause.name, kept.length ? ts.factory.updateNamedImports(bindings, kept) : undefined), statement.moduleSpecifier, statement.attributes)
+                : undefined;
+            importEdits.push({
+                start: statement.getStart(parsed),
+                end: statement.end,
+                text: updated ? printer.printNode(ts.EmitHint.Unspecified, updated, parsed) : ''
+            });
+        }
+        const neededImports = [...imports].filter((name) => !existingImports.has(name));
+        output =
+            (neededImports.length ? `import { ${neededImports.join(', ')} } from '@azure-net/kit/delivery';\n` : '') + apply(output, importEdits);
+        const updated = ts.createSourceFile(file, output, ts.ScriptTarget.Latest, true);
+        const references = [];
+        const visit = (node) => {
+            if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && converted.has(node.expression.text)) {
+                references.push({ start: node.expression.getStart(updated), end: node.expression.end, text: converted.get(node.expression.text) });
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(updated);
+        output = apply(output, references);
+    }
+    return { content: output, converted, issues };
+}

package/src/plugins/addLint.js

@@ -1,222 +1,55 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { execSync } from 'node:child_process';
-const dependencies = ['@commitlint/cli', 'semantic-release', '@semantic-release/git', 'git-cz', 'husky', 'commitizen', 'env-cmd'];
-const commitlintConfig = `export default {
-	rules: {
-		'body-leading-blank': [2, 'always'],
-		'footer-leading-blank': [2, 'always'],
-		'header-max-length': [2, 'always', 72],
-		'subject-empty': [2, 'never'],
-		'subject-full-stop': [2, 'never', '.'],
-		'type-case': [2, 'always', 'lower-case'],
-		'type-empty': [2, 'never'],
-		'type-enum': [2, 'always', ['feat', 'fix', 'refactor', 'perf', 'chore', 'docs', 'style', 'test', 'ci']]
-	}
-};
-`;
-const releaseConfig = `export default {
-	branches: ['main', 'dev'],
-	dryRun: false,
-	ci: false,
-	plugins: [
-		[
-			'@semantic-release/commit-analyzer',
-			{
-				releaseRules: [
-					{ type: 'release', release: 'major' },
-					{ type: 'feature', release: 'minor' },
-					{ type: 'perf', release: false },
-					{ type: 'refactor', release: false },
-					{ type: 'fix', release: 'patch' },
-					{ type: 'chore', release: false },
-					{ type: 'ci', release: false },
-					{ type: 'docs', scope: 'README', release: false },
-					{ type: 'test', release: false },
-					{ type: 'style', release: false }
-				]
-			}
-		],
-		'@semantic-release/release-notes-generator'
-	]
-};
-`;
-const prettierConfig = `{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"tabWidth": 2,
-	"semi": true,
-	"printWidth": 150,
-	"plugins": ["prettier-plugin-svelte"],
-	"overrides": [
-		{
-			"files": "*.svelte",
-			"options": {
-				"parser": "svelte"
-			}
-		}
-	]
-}
-`;
-const resolveInstallCommand = (manager) => {
-	const deps = dependencies.join(' ');
-	switch (manager) {
-		case 'pnpm':
-			return `pnpm add -D ${deps}`;
-		case 'npm':
-			return `npm install -D ${deps}`;
-		case 'yarn':
-			return `yarn add -D ${deps}`;
-		case 'bun':
-			return `bun add -d ${deps}`;
-	}
-};
-const resolveRunScriptCommand = (manager, script) => {
-	switch (manager) {
-		case 'pnpm':
-			return `pnpm ${script}`;
-		case 'npm':
-			return `npm run ${script}`;
-		case 'yarn':
-			return `yarn ${script}`;
-		case 'bun':
-			return `bun run ${script}`;
-	}
-};
-const resolveHuskyCommand = (manager) => {
-	switch (manager) {
-		case 'pnpm':
-			return 'pnpm exec husky';
-		case 'npm':
-			return 'npx husky';
-		case 'yarn':
-			return 'yarn husky';
-		case 'bun':
-			return 'bunx husky';
-	}
-};
-const detectPackageManager = (cwd) => {
-	if (fs.existsSync(path.join(cwd, 'bun.lock')) || fs.existsSync(path.join(cwd, 'bun.lockb'))) return 'bun';
-	if (fs.existsSync(path.join(cwd, 'pnpm-lock.yaml'))) return 'pnpm';
-	if (fs.existsSync(path.join(cwd, 'yarn.lock'))) return 'yarn';
-	if (fs.existsSync(path.join(cwd, 'package-lock.json'))) return 'npm';
-	return undefined;
-};
-const parseConfigState = (cwd) => {
-	const tsPath = path.join(cwd, 'azure-net.config.ts');
-	const jsPath = path.join(cwd, 'azure-net.config.js');
-	const configPath = fs.existsSync(tsPath) ? tsPath : fs.existsSync(jsPath) ? jsPath : null;
-	if (!configPath) {
-		return {
-			configPath: null,
-			content: null,
-			hasPackageManagerKey: false,
-			validPackageManager: null
-		};
-	}
-	const content = fs.readFileSync(configPath, 'utf-8');
-	const hasPackageManagerKey = /packageManager\s*:/.test(content);
-	const managerMatch = content.match(/packageManager\s*:\s*['"`](bun|pnpm|npm|yarn)['"`]/);
-	const validPackageManager = managerMatch?.[1];
-	return {
-		configPath,
-		content,
-		hasPackageManagerKey,
-		validPackageManager: validPackageManager ?? null
-	};
-};
-const upsertPackageManagerInConfig = (content, manager) => {
-	const packageManagerEntry = `packageManager: '${manager}'`;
-	const hasExportDefaultObject = /export\s+default\s*\{[\s\S]*\}\s*;?/.test(content);
-	if (!hasExportDefaultObject) {
-		return `export default {\n\t${packageManagerEntry}\n};\n`;
-	}
-	if (/packageManager\s*:/.test(content)) {
-		return content.replace(/packageManager\s*:\s*['"`][^'"`]+['"`]/, packageManagerEntry);
-	}
-	return content.replace(/export\s+default\s*\{([\s\S]*?)\}\s*;?/, (_full, body) => {
-		const trimmedRight = body.replace(/\s*$/, '');
-		if (!trimmedRight.length) {
-			return `export default {\n\t${packageManagerEntry}\n};`;
-		}
-		const withComma = trimmedRight.endsWith(',') ? trimmedRight : `${trimmedRight},`;
-		return `export default {${withComma}\n\t${packageManagerEntry}\n};`;
-	});
-};
-const localOnlyPrepareScript = `node -e "const local = !process.env.CI && process.env.NODE_ENV !== 'production' && !process.env.DOCKER && !process.env.CONTAINER; process.exit(local ? 1 : 0)" || (husky && svelte-kit sync)`;
-const selectPackageManager = async (cwd, preset) => {
-	if (preset) return preset;
-	const { default: prompts } = await import('prompts');
-	const detected = detectPackageManager(cwd);
-	const response = await prompts({
-		type: 'select',
-		name: 'manager',
-		message: 'Choose your package manager:',
-		choices: [
-			{ title: 'bun', value: 'bun' },
-			{ title: 'pnpm', value: 'pnpm' },
-			{ title: 'npm', value: 'npm' },
-			{ title: 'yarn', value: 'yarn' }
-		],
-		initial: detected ? ['bun', 'pnpm', 'npm', 'yarn'].indexOf(detected) : 0
-	});
-	if (!response.manager) {
-		throw new Error('Package manager is required');
-	}
-	return response.manager;
-};
-export default async function addLint(options = {}) {
-	const cwd = process.cwd();
-	const pkgPath = path.join(cwd, 'package.json');
-	if (!fs.existsSync(pkgPath)) {
-		console.error('❌ package.json not found in this directory');
-		process.exit(1);
-	}
-	const configState = parseConfigState(cwd);
-	const manager = configState.validPackageManager ?? (await selectPackageManager(cwd, options.manager));
-	if (!configState.configPath) {
-		const newConfigPath = path.join(cwd, 'azure-net.config.ts');
-		fs.writeFileSync(newConfigPath, `export default {\n\tpackageManager: '${manager}'\n};\n`);
-	} else if (!configState.validPackageManager || !configState.hasPackageManagerKey) {
-		const nextConfig = upsertPackageManagerInConfig(configState.content ?? '', manager);
-		fs.writeFileSync(configState.configPath, nextConfig);
-	}
-	const installCommand = resolveInstallCommand(manager);
-	const runFormatCommand = resolveRunScriptCommand(manager, 'format');
-	const preCommitScript = `${resolveRunScriptCommand(manager, 'lint')} && ${resolveRunScriptCommand(manager, 'check')}`;
-	const commitScript = `${resolveRunScriptCommand(manager, 'format')} && git add . && git-cz && git push`;
-	const releaseScript = `${resolveRunScriptCommand(manager, 'commit')} && ${resolveRunScriptCommand(manager, 'semantic-release')}`;
-	console.log(`📦 Installing packages with ${manager}...`);
-	execSync(installCommand, { stdio: 'inherit' });
-	console.log('📁 Updating package.json...');
-	const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
-	pkg.scripts = {
-		...(pkg.scripts ?? {}),
-		precommit: preCommitScript,
-		prepare: localOnlyPrepareScript,
-		'semantic-release': 'env-cmd semantic-release',
-		commit: commitScript,
-		release: releaseScript
-	};
-	pkg.config = pkg.config ?? {};
-	pkg.config.commitizen = {
-		path: 'git-cz'
-	};
-	fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 4));
-	fs.writeFileSync(path.join(cwd, 'commitlint.config.ts'), commitlintConfig);
-	fs.writeFileSync(path.join(cwd, 'release.config.ts'), releaseConfig);
-	fs.writeFileSync(path.join(cwd, '.prettierrc'), prettierConfig);
-	console.log('🔧 Initializing Husky...');
-	try {
-		execSync(resolveHuskyCommand(manager), { stdio: 'inherit' });
-	} catch {
-		console.warn('⚠️ Husky initialization skipped (command failed in current environment).');
-	}
-	try {
-		execSync(runFormatCommand, { stdio: 'inherit' });
-	} catch {
-		console.warn('⚠️ Format script execution skipped (script may be missing).');
-	}
-	console.log(`✅ Linting and release setup completed! Added prepare script: ${localOnlyPrepareScript}`);
+export default async function addLint(_options = {}) {
+    // Retain compatibility with the existing --manager option without running a package manager.
+    void _options;
+    const cwd = process.cwd();
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath))
+        throw new Error('package.json not found in this directory');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    const configNames = [
+        '.prettierrc',
+        '.prettierrc.json',
+        '.prettierrc.json5',
+        '.prettierrc.yaml',
+        '.prettierrc.yml',
+        '.prettierrc.toml',
+        '.prettierrc.js',
+        '.prettierrc.cjs',
+        '.prettierrc.mjs',
+        '.prettierrc.ts',
+        '.prettierrc.cts',
+        '.prettierrc.mts',
+        'prettier.config.js',
+        'prettier.config.cjs',
+        'prettier.config.mjs',
+        'prettier.config.ts',
+        'prettier.config.cts',
+        'prettier.config.mts'
+    ];
+    const existingConfigs = configNames.filter((name) => fs.existsSync(path.join(cwd, name)));
+    if ('prettier' in pkg || existingConfigs.length) {
+        const backupRoot = path.join(cwd, '.azure-net', 'PrettierBackups');
+        fs.mkdirSync(backupRoot, { recursive: true });
+        // Atomic directory creation prevents overwriting backups from rapid repeated runs.
+        const backup = fs.mkdtempSync(path.join(backupRoot, 'config-'));
+        if ('prettier' in pkg) {
+            fs.copyFileSync(pkgPath, path.join(backup, 'package.json'), fs.constants.COPYFILE_EXCL);
+            delete pkg.prettier;
+            fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, '\t') + '\n');
+        }
+        for (const name of existingConfigs) {
+            fs.renameSync(path.join(cwd, name), path.join(backup, name));
+        }
+    }
+    fs.writeFileSync(path.join(cwd, '.prettierrc'), JSON.stringify({
+        useTabs: true,
+        singleQuote: true,
+        trailingComma: 'none',
+        tabWidth: 2,
+        semi: true,
+        printWidth: 150
+    }, null, '\t') + '\n');
+    console.log('Prettier configuration replaced. No packages installed.');
 }