@smoothbricks/cli 0.1.1 → 0.2.0

package/dist/monorepo/package-policy.js

@@ -1,8 +1,80 @@
-import { join } from 'node:path';
-import { getOrCreateRecord, hasOwnString, isRecord, readJsonObject, recordProperty, requiredJsonObject, setMissingStringProperty, setStringProperty, stringProperty, writeJsonObject, } from '../lib/json.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { getOrCreateRecord, hasOwn, hasOwnString, isRecord, readJsonObject, recordProperty, requiredJsonObject, setMissingStringProperty, setStringProperty, stringProperty, writeJsonObject, } from '../lib/json.js';
 import { getWorkspacePackages, listPackageJsonRecords, listPublicPackages, packageRepositoryInfo, repositoryInfo, sameRepositoryAfterNormalization, workspaceDependencyFields, } from '../lib/workspace.js';
 export const SMOO_NX_VERSION_ACTIONS = '@smoothbricks/cli/nx-version-actions';
 export const SMOO_NX_RELEASE_TAG_PATTERN = '{projectName}@{version}';
+const extraCommitScopes = ['release'];
+const rootScriptPolicy = {
+    lint: 'nx run-many -t lint',
+    'lint:fix': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --unstaged',
+    'format:staged': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml',
+    'format:changed': 'git-format-staged --config tooling/git-hooks/git-format-staged.yml --also-unstaged',
+};
+const nxJsTypescriptPlugin = '@nx/js/typescript';
+const smoothBricksNxPlugin = '@smoothbricks/nx-plugin';
+const expectedSharedGlobalsNamedInput = ['{workspaceRoot}/.github/workflows/ci.yml'];
+const defaultProductionNamedInput = [
+    '{projectRoot}/src/**/*',
+    '{projectRoot}/package.json',
+    '!{projectRoot}/**/__tests__/**',
+    '!{projectRoot}/**/*.test.*',
+    '!{projectRoot}/**/*.spec.*',
+];
+const impreciseProductionInputs = new Set(['default', '{projectRoot}/**/*', '{projectRoot}/**']);
+export function applyFixableMonorepoDefaults(root) {
+    applyRootScriptDefaults(root);
+    applyNxPluginDefaults(root);
+    applyNxProjectNameDefaults(root);
+}
+export function applyRootScriptDefaults(root) {
+    const rootPackagePath = join(root, 'package.json');
+    const rootPackage = readJsonObject(rootPackagePath);
+    if (!rootPackage) {
+        return;
+    }
+    const scripts = getOrCreateRecord(rootPackage, 'scripts');
+    let changed = false;
+    for (const [name, command] of Object.entries(rootScriptPolicy)) {
+        changed = setStringProperty(scripts, name, command) || changed;
+    }
+    const nx = getOrCreateRecord(rootPackage, 'nx');
+    if (!Array.isArray(nx.includedScripts) || nx.includedScripts.length !== 0) {
+        nx.includedScripts = [];
+        changed = true;
+    }
+    changed = sortRecordInPlace(scripts) || changed;
+    if (changed) {
+        writeJsonObject(rootPackagePath, rootPackage);
+        console.log('updated        package.json root smoo scripts');
+    }
+    else {
+        console.log('unchanged      package.json root smoo scripts');
+    }
+}
+export function applyNxPluginDefaults(root) {
+    const nxJsonPath = join(root, 'nx.json');
+    const nxJson = readJsonObject(nxJsonPath);
+    if (!nxJson) {
+        return;
+    }
+    let changed = removeColonTargetDefaults(nxJson);
+    changed = applyBuildTargetDefault(nxJson) || changed;
+    changed = applyNamedInputDefaults(nxJson) || changed;
+    const currentPlugins = Array.isArray(nxJson.plugins) ? nxJson.plugins : [];
+    const nextPlugins = upsertNxPlugin(upsertNxPlugin(currentPlugins, expectedNxJsTypescriptPlugin()), smoothBricksNxPlugin);
+    if (JSON.stringify(currentPlugins) !== JSON.stringify(nextPlugins)) {
+        nxJson.plugins = nextPlugins;
+        changed = true;
+    }
+    if (changed) {
+        writeJsonObject(nxJsonPath, nxJson);
+        console.log('updated        nx.json smoo plugin config');
+    }
+    else {
+        console.log('unchanged      nx.json smoo plugin config');
+    }
+}
 export function applyPublicPackageDefaults(root) {
     const rootPackage = requiredJsonObject(join(root, 'package.json'));
     const rootLicense = stringProperty(rootPackage, 'license');
@@ -39,17 +111,27 @@ export function applyPublicPackageDefaults(root) {
         }
     }
 }
-export function applyWorkspaceDependencyDefaults(root) {
+export function applyWorkspaceDependencyDefaults(root, options = {}) {
     const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     for (const pkg of listPackageJsonRecords(root)) {
-        const changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
+        let changed = fixWorkspaceDependencyRanges(pkg.json, workspaceNames);
+        const projectName = packageNxProjectName(pkg.json);
+        const resolvedProject = projectName ? options.resolvedTargetsByProject?.get(projectName) : undefined;
+        const resolvedTargets = resolvedProjectTargetNames(resolvedProject);
+        changed = migratePackageColonTargets(pkg.json, resolvedTargets) || changed;
+        changed = rewriteColonTargetDependenciesInPackage(pkg.json, resolvedTargets) || changed;
+        changed = removePackageColonTargets(pkg.json) || changed;
+        changed = removeRedundantNoopBuildTarget(pkg.json, resolvedProject) || changed;
+        changed = applyPackageScriptPolicy(pkg.json, pkg.path, workspaceNames, { resolvedTargets }) || changed;
         if (changed) {
             writeJsonObject(pkg.packageJsonPath, pkg.json);
-            console.log(`updated        ${pkg.path}/package.json workspace dependency ranges`);
+            console.log(`updated        ${pkg.path}/package.json workspace dependency policy`);
         }
         else {
-            console.log(`unchanged      ${pkg.path}/package.json workspace dependency ranges`);
+            console.log(`unchanged      ${pkg.path}/package.json workspace dependency policy`);
         }
+        applyBunTestTsconfigDefaults(root, pkg.path, pkg.json, workspaceNames);
+        applyTsconfigTestReferenceDefaults(root, pkg.path);
     }
 }
 export function applyNxReleaseDefaults(root) {
@@ -90,6 +172,47 @@ export function applyNxReleaseDefaults(root) {
         console.log('unchanged      nx.json release config');
     }
 }
+export function applyNxProjectNameDefaults(root) {
+    const rootPackage = requiredJsonObject(join(root, 'package.json'));
+    const rootName = stringProperty(rootPackage, 'name');
+    if (!rootName) {
+        return;
+    }
+    for (const pkg of getWorkspacePackages(root)) {
+        const suggestedName = suggestNxProjectName(rootName, pkg.name);
+        if (!suggestedName) {
+            continue;
+        }
+        const changed = applyPackageNxConfig(pkg.json, { projectName: suggestedName }).changed;
+        if (changed) {
+            writeJsonObject(pkg.packageJsonPath, pkg.json);
+            console.log(`updated        ${pkg.path}/package.json nx.name`);
+        }
+        else {
+            console.log(`unchanged      ${pkg.path}/package.json nx.name`);
+        }
+    }
+}
+export function listValidCommitScopes(root) {
+    return new Set([...listNxProjectNames(root), ...extraCommitScopes]);
+}
+export function listNxProjectNames(root) {
+    const rootPackage = readJsonObject(join(root, 'package.json'));
+    const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+    const names = [];
+    for (const pkg of getWorkspacePackages(root)) {
+        const nx = recordProperty(pkg.json, 'nx');
+        const configuredName = nx ? stringProperty(nx, 'name') : null;
+        const suggestedName = rootName ? suggestNxProjectName(rootName, pkg.name) : null;
+        if (configuredName) {
+            names.push(configuredName);
+        }
+        else if (suggestedName) {
+            names.push(suggestedName);
+        }
+    }
+    return names;
+}
 export function validateRootPackagePolicy(root) {
     const rootPackage = readJsonObject(join(root, 'package.json'));
     if (!rootPackage) {
@@ -109,6 +232,8 @@ export function validateRootPackagePolicy(root) {
         console.error('package.json must define repository.url');
         failures++;
     }
+    failures += validateRootScripts(rootPackage);
+    failures += validateRootNxScriptInference(rootPackage);
     const packageManager = stringProperty(rootPackage, 'packageManager');
     if (!packageManager?.startsWith('bun@')) {
         console.error('package.json packageManager must use bun@<version>');
@@ -144,6 +269,7 @@ export function validateNxReleaseConfig(root) {
         console.error('nx.json release config is missing');
         failures++;
     }
+    failures += validateNxPluginConfig(nxJson);
     if (release && stringProperty(release, 'projectsRelationship') !== 'independent') {
         console.error('nx.json release.projectsRelationship must be independent');
         failures++;
@@ -208,6 +334,30 @@ export function validateNxReleaseConfig(root) {
     }
     return failures;
 }
+export function validateNxProjectNames(root) {
+    const rootPackage = readJsonObject(join(root, 'package.json'));
+    const rootName = rootPackage ? stringProperty(rootPackage, 'name') : null;
+    if (!rootName) {
+        return 0;
+    }
+    let failures = 0;
+    for (const pkg of getWorkspacePackages(root)) {
+        const suggestedName = suggestNxProjectName(rootName, pkg.name);
+        if (!suggestedName) {
+            continue;
+        }
+        const nx = recordProperty(pkg.json, 'nx');
+        const configuredName = nx ? stringProperty(nx, 'name') : null;
+        if (configuredName !== suggestedName) {
+            console.error(`${pkg.path}: package.json nx.name must be "${suggestedName}" so fix(${suggestedName}): maps to this project`);
+            failures++;
+        }
+    }
+    if (failures === 0) {
+        console.log('Nx project names are valid.');
+    }
+    return failures;
+}
 export function validatePublicTags(root) {
     let failures = 0;
     for (const pkg of getWorkspacePackages(root)) {
@@ -278,10 +428,17 @@ export function validatePublicPackageMetadata(root) {
     }
     return failures;
 }
-export function validateWorkspaceDependencies(root) {
+export function validateWorkspaceDependencies(root, options = {}) {
     const workspaceNames = new Set(getWorkspacePackages(root).map((pkg) => pkg.name));
     let failures = 0;
     for (const pkg of listPackageJsonRecords(root)) {
+        const projectName = packageNxProjectName(pkg.json);
+        const resolvedTargets = resolvedProjectTargetNames(projectName ? options.resolvedTargetsByProject?.get(projectName) : undefined);
+        failures += validateExplicitNxTargets(pkg.json, pkg.path, resolvedTargets);
+        failures += validateBunTestTsconfigPresence(root, pkg.path, pkg.json);
+        failures += validateTsconfigTestPolicy(root, pkg.path);
+        failures += validateTsconfigTestReferencePolicy(root, pkg.path);
+        failures += validateBuildZigPolicy(root, pkg.path);
         for (const field of workspaceDependencyFields) {
             const dependencies = recordProperty(pkg.json, field);
             if (!dependencies) {
@@ -294,9 +451,148 @@ export function validateWorkspaceDependencies(root) {
                 }
             }
         }
+        failures += validatePackageScriptPolicy(pkg.json, pkg.path, workspaceNames, { resolvedTargets });
     }
     if (failures === 0) {
-        console.log('Workspace dependency ranges are valid.');
+        console.log('Workspace dependency policy is valid.');
+    }
+    return failures;
+}
+export function applyPackageScriptPolicy(pkg, _packagePath, workspaceNames, options = {}) {
+    if (!hasWorkspaceDependency(pkg, workspaceNames)) {
+        return false;
+    }
+    const scripts = recordProperty(pkg, 'scripts');
+    if (!scripts) {
+        return false;
+    }
+    const projectName = packageNxProjectName(pkg);
+    if (!projectName) {
+        return false;
+    }
+    const nxConfig = applyPackageNxConfig(pkg, { projectName, targets: true });
+    const targets = nxConfig.targets;
+    let changed = nxConfig.changed;
+    for (const [scriptName, rawCommand] of Object.entries(scripts)) {
+        if (typeof rawCommand !== 'string') {
+            continue;
+        }
+        const rewrite = classifyScriptRewrite(scriptName, rawCommand);
+        if (!rewrite) {
+            continue;
+        }
+        const targetName = rewrite.targetName;
+        const alias = nxRunAlias(projectName, targetName, rewrite.continuous);
+        const existingTarget = recordProperty(targets, targetName);
+        if (!existingTarget &&
+            targetName !== scriptName &&
+            targetExistsInResolvedProject(targetName, options.resolvedTargets)) {
+            if (scripts[scriptName] !== alias) {
+                scripts[scriptName] = alias;
+                changed = true;
+            }
+            continue;
+        }
+        const existingOptions = existingTarget ? recordProperty(existingTarget, 'options') : null;
+        const existingCommand = existingOptions ? stringProperty(existingOptions, 'command') : null;
+        const command = isScriptRunnerCommand(existingCommand, scriptName)
+            ? rewrite.command
+            : (existingCommand ?? rewrite.command);
+        const target = existingTarget ?? {};
+        changed = setStringProperty(target, 'executor', 'nx:run-commands') || changed;
+        changed = setStringArrayProperty(target, 'dependsOn', expectedTargetDependencies(targetName)) || changed;
+        if (rewrite.continuous && target.continuous !== true) {
+            target.continuous = true;
+            changed = true;
+        }
+        const targetOptions = getOrCreateRecord(target, 'options');
+        changed = setStringProperty(targetOptions, 'command', command) || changed;
+        changed = setStringProperty(targetOptions, 'cwd', '{projectRoot}') || changed;
+        for (const [name, value] of Object.entries(rewrite.env)) {
+            const env = getOrCreateRecord(targetOptions, 'env');
+            changed = setStringProperty(env, name, value) || changed;
+        }
+        if (targets[targetName] !== target) {
+            targets[targetName] = target;
+            changed = true;
+        }
+        if (scripts[scriptName] !== alias) {
+            scripts[scriptName] = alias;
+            changed = true;
+        }
+    }
+    return changed;
+}
+export function validatePackageScriptPolicy(pkg, packagePath, workspaceNames, options = {}) {
+    if (!hasWorkspaceDependency(pkg, workspaceNames)) {
+        return 0;
+    }
+    const scripts = recordProperty(pkg, 'scripts');
+    if (!scripts) {
+        return 0;
+    }
+    const nx = recordProperty(pkg, 'nx');
+    const projectName = nx ? stringProperty(nx, 'name') : stringProperty(pkg, 'name');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    let failures = 0;
+    for (const [scriptName, rawCommand] of Object.entries(scripts)) {
+        if (typeof rawCommand !== 'string') {
+            continue;
+        }
+        const alias = parseNxRunAlias(rawCommand);
+        const rewrite = alias
+            ? { targetName: alias.targetName, continuous: isContinuousTarget(alias.targetName, '') }
+            : classifyScriptRewrite(scriptName, rawCommand);
+        if (!rewrite || (alias && projectName && alias.projectName !== projectName)) {
+            if (alias && projectName && alias.projectName !== projectName) {
+                console.error(`${packagePath}: scripts.${scriptName} must delegate to project ${projectName}`);
+                failures++;
+            }
+            continue;
+        }
+        if (!projectName) {
+            console.error(`${packagePath}: package scripts that use workspace dependencies require package.json nx.name`);
+            failures++;
+            continue;
+        }
+        const expectedAlias = nxRunAlias(projectName, rewrite.targetName, rewrite.continuous);
+        if (rawCommand !== expectedAlias) {
+            console.error(`${packagePath}: scripts.${scriptName} must delegate to ${expectedAlias}`);
+            failures++;
+            continue;
+        }
+        const target = targets ? recordProperty(targets, rewrite.targetName) : null;
+        if (!target &&
+            rewrite.targetName !== scriptName &&
+            targetExistsInResolvedProject(rewrite.targetName, options.resolvedTargets)) {
+            continue;
+        }
+        if (rewrite.targetName.includes(':')) {
+            continue;
+        }
+        const targetOptions = target ? recordProperty(target, 'options') : null;
+        const command = targetOptions ? stringProperty(targetOptions, 'command') : null;
+        if (!target || stringProperty(target, 'executor') !== 'nx:run-commands' || !targetOptions || !command) {
+            console.error(`${packagePath}: nx.targets.${rewrite.targetName} must use nx:run-commands with options.command`);
+            failures++;
+            continue;
+        }
+        if (stringProperty(targetOptions, 'cwd') !== '{projectRoot}') {
+            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.options.cwd must be {projectRoot}`);
+            failures++;
+        }
+        if (!targetDependsOn(target, expectedTargetDependencies(rewrite.targetName))) {
+            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.dependsOn must include ${expectedTargetDependencies(rewrite.targetName).join(', ')}`);
+            failures++;
+        }
+        if (rewrite.continuous && target.continuous !== true) {
+            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.continuous must be true`);
+            failures++;
+        }
+        if (isScriptRunnerCommand(command, scriptName)) {
+            console.error(`${packagePath}: nx.targets.${rewrite.targetName}.options.command must not call scripts.${scriptName}`);
+            failures++;
+        }
     }
     return failures;
 }
@@ -316,6 +612,869 @@ function fixWorkspaceDependencyRanges(pkg, workspaceNames) {
     }
     return changed;
 }
+function validateRootScripts(rootPackage) {
+    const scripts = recordProperty(rootPackage, 'scripts');
+    let failures = 0;
+    for (const [name, command] of Object.entries(rootScriptPolicy)) {
+        if (scripts?.[name] !== command) {
+            console.error(`package.json scripts.${name} must be ${command}`);
+            failures++;
+        }
+    }
+    if (scripts && !recordKeysAreSorted(scripts)) {
+        console.error('package.json scripts must be sorted alphabetically so root command policy stays stable across fixes.');
+        failures++;
+    }
+    return failures;
+}
+function validateRootNxScriptInference(rootPackage) {
+    const nx = recordProperty(rootPackage, 'nx');
+    if (nx && Array.isArray(nx.includedScripts) && nx.includedScripts.length === 0) {
+        return 0;
+    }
+    console.error('package.json nx.includedScripts must be [] so root scripts do not become recursive Nx targets.');
+    return 1;
+}
+function validateNxPluginConfig(nxJson) {
+    let failures = 0;
+    const targetDefaults = recordProperty(nxJson, 'targetDefaults');
+    if (targetDefaults) {
+        for (const targetName of Object.keys(targetDefaults)) {
+            if (targetName.includes(':')) {
+                console.error(`nx.json targetDefaults.${targetName} must not use colon target names. ` +
+                    'Nx CLI syntax already uses project:target:configuration, so smoo Nx target names must be unambiguous tool-output names.');
+                failures++;
+            }
+        }
+    }
+    failures += validateBuildTargetDefault(nxJson);
+    failures += validateNamedInputDefaults(nxJson);
+    const plugins = Array.isArray(nxJson.plugins) ? nxJson.plugins : [];
+    const nxJsPlugin = plugins.find(isNxJsTypescriptPlugin);
+    if (!nxJsPlugin) {
+        console.error(`nx.json plugins must configure ${nxJsTypescriptPlugin}. ` +
+            'Official Nx owns TypeScript library inference; smoo configures it so tsconfig.lib.json produces tsc-js and leaves build available as an aggregate target.');
+        failures++;
+    }
+    else if (nxJsBuildTargetName(nxJsPlugin) !== 'tsc-js') {
+        console.error(`nx.json ${nxJsTypescriptPlugin} build.targetName must be tsc-js. ` +
+            'TypeScript library output is a concrete tool-output target; build is reserved for aggregate targets that depend on concrete build work.');
+        failures++;
+    }
+    if (!plugins.includes(smoothBricksNxPlugin) && !plugins.some(isSmoothBricksNxPluginRecord)) {
+        console.error(`nx.json plugins must include ${smoothBricksNxPlugin}. ` +
+            'Smoo relies on this plugin to infer convention targets that official Nx does not provide, including typecheck-tests, non-TypeScript build-tool targets, and aggregate build/lint targets.');
+        failures++;
+    }
+    return failures;
+}
+function validateExplicitNxTargets(pkg, packagePath, resolvedTargets) {
+    const nx = recordProperty(pkg, 'nx');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    if (!targets) {
+        return 0;
+    }
+    let failures = 0;
+    for (const [targetName, rawTarget] of Object.entries(targets)) {
+        if (targetName.includes(':')) {
+            console.error(`${packagePath}: package.json nx.targets.${targetName} must not use colon target names. ` +
+                'Nx CLI syntax already uses project:target:configuration; use a concrete tool-output target name and keep colon names only as package-script aliases.');
+            failures++;
+        }
+        if (!isRecord(rawTarget)) {
+            continue;
+        }
+        failures += validateTargetDependencies(rawTarget, `${packagePath}: nx.targets.${targetName}`, resolvedTargets);
+    }
+    return failures;
+}
+function validateTargetDependencies(target, label, resolvedTargets) {
+    if (!Array.isArray(target.dependsOn)) {
+        return 0;
+    }
+    let failures = 0;
+    for (const dependency of target.dependsOn) {
+        if (typeof dependency !== 'string') {
+            continue;
+        }
+        if (dependency.includes(':')) {
+            console.error(`${label}.dependsOn must not include colon target dependency ${dependency}`);
+            failures++;
+            continue;
+        }
+        if (label.endsWith('nx.targets.build') &&
+            !dependency.startsWith('^') &&
+            !targetExistsInResolvedProject(dependency, resolvedTargets)) {
+            console.error(`${label}.dependsOn references missing target ${dependency}`);
+            failures++;
+        }
+    }
+    return failures;
+}
+function validateTsconfigTestPolicy(root, packagePath) {
+    const path = join(root, packagePath, 'tsconfig.test.json');
+    const tsconfig = readJsonObject(path);
+    if (!tsconfig) {
+        return 0;
+    }
+    const compilerOptions = recordProperty(tsconfig, 'compilerOptions');
+    let failures = 0;
+    if (!compilerOptions || compilerOptions.noEmit !== true) {
+        console.error(`${packagePath}/tsconfig.test.json compilerOptions.noEmit must be true`);
+        failures++;
+    }
+    if (compilerOptions?.composite === true) {
+        console.error(`${packagePath}/tsconfig.test.json must not set compilerOptions.composite = true. ` +
+            'Bun test typechecking is a no-emit validation pass, not a TypeScript build-mode project.');
+        failures++;
+    }
+    if (compilerOptions?.declaration === true) {
+        console.error(`${packagePath}/tsconfig.test.json must not set compilerOptions.declaration = true`);
+        failures++;
+    }
+    if (compilerOptions?.declarationMap === true) {
+        console.error(`${packagePath}/tsconfig.test.json must not set compilerOptions.declarationMap = true`);
+        failures++;
+    }
+    if (compilerOptions?.outDir === 'dist-test') {
+        console.error(`${packagePath}/tsconfig.test.json must not emit to dist-test`);
+        failures++;
+    }
+    if (typeof compilerOptions?.tsBuildInfoFile === 'string' && compilerOptions.tsBuildInfoFile.includes('dist-test')) {
+        console.error(`${packagePath}/tsconfig.test.json must not write tsbuildinfo under dist-test`);
+        failures++;
+    }
+    return failures;
+}
+function validateTsconfigTestReferencePolicy(root, packagePath) {
+    const testTsconfigPath = join(root, packagePath, 'tsconfig.test.json');
+    if (!existsSync(testTsconfigPath)) {
+        return 0;
+    }
+    const projectTsconfig = readJsonObject(join(root, packagePath, 'tsconfig.json'));
+    if (!projectTsconfigHasTestReference(projectTsconfig)) {
+        return 0;
+    }
+    console.error(`${packagePath}/tsconfig.json must not reference ./tsconfig.test.json. ` +
+        'Test typechecking is run by the inferred typecheck-tests target with tsc --noEmit, not TypeScript build mode.');
+    return 1;
+}
+function validateBunTestTsconfigPresence(root, packagePath, pkg) {
+    if (!usesBunTest(pkg)) {
+        return 0;
+    }
+    const path = join(root, packagePath, 'tsconfig.test.json');
+    if (existsSync(path)) {
+        return 0;
+    }
+    console.error(`${packagePath}: bun test requires tsconfig.test.json because Bun executes tests without typechecking. ` +
+        'Run smoo monorepo validate --fix to create the no-emit test typecheck config.');
+    return 1;
+}
+function applyBunTestTsconfigDefaults(root, packagePath, pkg, workspaceNames) {
+    if (!usesBunTest(pkg)) {
+        return;
+    }
+    const tsconfigTestPath = join(root, packagePath, 'tsconfig.test.json');
+    const existing = readJsonObject(tsconfigTestPath);
+    const tsconfigTest = existing ?? {};
+    let changed = existing === null;
+    changed = applyTsconfigTestDefaults(root, packagePath, pkg, tsconfigTest, workspaceNames) || changed;
+    if (changed) {
+        writeJsonObject(tsconfigTestPath, tsconfigTest);
+        console.log(`updated        ${packagePath}/tsconfig.test.json bun test typecheck config`);
+    }
+    else {
+        console.log(`unchanged      ${packagePath}/tsconfig.test.json bun test typecheck config`);
+    }
+}
+function applyTsconfigTestReferenceDefaults(root, packagePath) {
+    const projectTsconfigPath = join(root, packagePath, 'tsconfig.json');
+    const projectTsconfig = readJsonObject(projectTsconfigPath);
+    if (!projectTsconfig || !projectTsconfigHasTestReference(projectTsconfig)) {
+        return;
+    }
+    const references = Array.isArray(projectTsconfig.references) ? projectTsconfig.references : [];
+    projectTsconfig.references = references.filter((entry) => !isRecord(entry) || entry.path !== './tsconfig.test.json');
+    writeJsonObject(projectTsconfigPath, projectTsconfig);
+    console.log(`updated        ${packagePath}/tsconfig.json removed test project reference`);
+}
+function applyTsconfigTestDefaults(root, packagePath, pkg, tsconfigTest, workspaceNames) {
+    let changed = setMissingStringProperty(tsconfigTest, 'extends', defaultTsconfigTestExtends(root, packagePath));
+    const compilerOptions = getOrCreateRecord(tsconfigTest, 'compilerOptions');
+    changed = copyLibCompilerOptions(root, packagePath, compilerOptions) || changed;
+    changed = setBooleanProperty(compilerOptions, 'composite', false) || changed;
+    changed = setBooleanProperty(compilerOptions, 'declaration', false) || changed;
+    changed = setBooleanProperty(compilerOptions, 'declarationMap', false) || changed;
+    changed = setBooleanProperty(compilerOptions, 'emitDeclarationOnly', false) || changed;
+    changed = setBooleanProperty(compilerOptions, 'noEmit', true) || changed;
+    changed = mergeStringListProperty(compilerOptions, 'types', ['bun']) || changed;
+    if (delete compilerOptions.outDir) {
+        changed = true;
+    }
+    if (delete compilerOptions.tsBuildInfoFile) {
+        changed = true;
+    }
+    changed =
+        mergeStringListProperty(tsconfigTest, 'include', [
+            'src/**/*.test.ts',
+            'src/**/*.spec.ts',
+            'src/**/__tests__/**/*.ts',
+            'src/**/__tests__/**/*.tsx',
+            'src/test-suite-tracer.ts',
+        ]) || changed;
+    for (const referencePath of collectTsconfigTestReferencePaths(root, packagePath, pkg, workspaceNames)) {
+        changed = addTsconfigReference(tsconfigTest, referencePath) || changed;
+    }
+    return changed;
+}
+function defaultTsconfigTestExtends(root, packagePath) {
+    const libTsconfig = readJsonObject(join(root, packagePath, 'tsconfig.lib.json'));
+    return stringProperty(libTsconfig ?? {}, 'extends') ?? '../../tsconfig.base.json';
+}
+function copyLibCompilerOptions(root, packagePath, target) {
+    const libTsconfig = readJsonObject(join(root, packagePath, 'tsconfig.lib.json'));
+    const libCompilerOptions = libTsconfig ? recordProperty(libTsconfig, 'compilerOptions') : null;
+    if (!libCompilerOptions) {
+        return false;
+    }
+    let changed = false;
+    for (const key of ['baseUrl', 'module', 'moduleResolution', 'jsx', 'lib']) {
+        if (hasOwn(libCompilerOptions, key) && target[key] !== libCompilerOptions[key]) {
+            target[key] = libCompilerOptions[key];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function collectTsconfigTestReferencePaths(root, packagePath, pkg, workspaceNames) {
+    const paths = existsSync(join(root, packagePath, 'tsconfig.lib.json')) ? ['./tsconfig.lib.json'] : [];
+    const packagesByName = new Map(getWorkspacePackages(root).map((workspacePkg) => [workspacePkg.name, workspacePkg]));
+    for (const field of workspaceDependencyFields) {
+        const dependencies = recordProperty(pkg, field);
+        if (!dependencies) {
+            continue;
+        }
+        for (const dependencyName of Object.keys(dependencies)) {
+            if (!workspaceNames.has(dependencyName)) {
+                continue;
+            }
+            const dependencyPackage = packagesByName.get(dependencyName);
+            if (!dependencyPackage) {
+                continue;
+            }
+            const dependencyTsconfig = join(root, dependencyPackage.path, 'tsconfig.lib.json');
+            if (!existsSync(dependencyTsconfig)) {
+                continue;
+            }
+            const refPath = relative(join(root, packagePath), dependencyTsconfig).replaceAll('\\', '/');
+            if (!paths.includes(refPath)) {
+                paths.push(refPath);
+            }
+        }
+    }
+    return paths;
+}
+function usesBunTest(pkg) {
+    const scripts = recordProperty(pkg, 'scripts');
+    if (scripts && Object.values(scripts).some((command) => typeof command === 'string' && isBunTestCommand(command))) {
+        return true;
+    }
+    const nx = recordProperty(pkg, 'nx');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    if (!targets) {
+        return false;
+    }
+    for (const target of Object.values(targets)) {
+        if (!isRecord(target)) {
+            continue;
+        }
+        const options = recordProperty(target, 'options');
+        const command = options ? stringProperty(options, 'command') : null;
+        if (command && isBunTestCommand(command)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isBunTestCommand(command) {
+    return /^bun\s+test(?:\s|$)/.test(parseEnvPrefixedCommand(command).command.trim());
+}
+function mergeStringListProperty(record, key, values) {
+    const rawCurrent = record[key];
+    const current = Array.isArray(rawCurrent)
+        ? rawCurrent.filter((entry) => typeof entry === 'string')
+        : [];
+    const next = [...current];
+    for (const value of values) {
+        if (!next.includes(value)) {
+            next.push(value);
+        }
+    }
+    if (Array.isArray(rawCurrent) &&
+        next.length === rawCurrent.length &&
+        next.every((entry, index) => entry === rawCurrent[index])) {
+        return false;
+    }
+    record[key] = next;
+    return true;
+}
+function addTsconfigReference(tsconfig, path) {
+    const current = Array.isArray(tsconfig.references)
+        ? tsconfig.references.filter((entry) => isRecord(entry))
+        : [];
+    if (current.some((entry) => entry.path === path)) {
+        return false;
+    }
+    tsconfig.references = [...current, { path }];
+    return true;
+}
+function projectTsconfigHasTestReference(projectTsconfig) {
+    return Boolean(projectTsconfig &&
+        Array.isArray(projectTsconfig.references) &&
+        projectTsconfig.references.some((entry) => isRecord(entry) && entry.path === './tsconfig.test.json'));
+}
+function validateBuildZigPolicy(root, packagePath) {
+    const path = join(root, packagePath, 'build.zig');
+    if (!existsSync(path)) {
+        return 0;
+    }
+    if (/\bb\.step\s*\(/.test(readFileSync(path, 'utf8'))) {
+        return 0;
+    }
+    console.error(`${packagePath}/build.zig must define at least one b.step(...) target`);
+    return 1;
+}
+function applyBuildTargetDefault(nxJson) {
+    const targetDefaults = getOrCreateRecord(nxJson, 'targetDefaults');
+    const build = getOrCreateRecord(targetDefaults, 'build');
+    let changed = setBooleanProperty(build, 'cache', true);
+    changed = setStringArrayProperty(build, 'outputs', ['{projectRoot}/dist']) || changed;
+    return changed;
+}
+function validateBuildTargetDefault(nxJson) {
+    const targetDefaults = recordProperty(nxJson, 'targetDefaults');
+    const build = targetDefaults ? recordProperty(targetDefaults, 'build') : null;
+    let failures = 0;
+    if (!build || build.cache !== true) {
+        console.error('nx.json targetDefaults.build.cache must be true');
+        failures++;
+    }
+    const outputs = build?.outputs;
+    if (!Array.isArray(outputs) || outputs.length !== 1 || outputs[0] !== '{projectRoot}/dist') {
+        console.error('nx.json targetDefaults.build.outputs must be ["{projectRoot}/dist"]');
+        failures++;
+    }
+    return failures;
+}
+function applyNamedInputDefaults(nxJson) {
+    const namedInputs = getOrCreateRecord(nxJson, 'namedInputs');
+    let changed = false;
+    if (!Array.isArray(namedInputs.default)) {
+        namedInputs.default = ['{projectRoot}/**/*', 'sharedGlobals'];
+        changed = true;
+    }
+    changed = setStringArrayProperty(namedInputs, 'sharedGlobals', expectedSharedGlobalsNamedInput) || changed;
+    const production = namedInputs.production;
+    if (!Array.isArray(production) || !isPreciseProductionNamedInput(production)) {
+        namedInputs.production = defaultProductionNamedInput;
+        changed = true;
+    }
+    return changed;
+}
+function validateNamedInputDefaults(nxJson) {
+    const namedInputs = recordProperty(nxJson, 'namedInputs');
+    const production = namedInputs?.production;
+    let failures = 0;
+    if (!namedInputs) {
+        console.error('nx.json namedInputs must be configured so production builds have precise cache inputs.');
+        return 1;
+    }
+    if (!Array.isArray(namedInputs.default)) {
+        console.error('nx.json namedInputs.default must be an array; smoo allows it to remain broad for non-production tasks.');
+        failures++;
+    }
+    if (!stringArrayEquals(namedInputs.sharedGlobals, expectedSharedGlobalsNamedInput)) {
+        console.error('nx.json namedInputs.sharedGlobals must include only {workspaceRoot}/.github/workflows/ci.yml');
+        failures++;
+    }
+    if (!Array.isArray(production)) {
+        console.error('nx.json namedInputs.production must be an array of precise production inputs.');
+        return failures + 1;
+    }
+    if (!isPreciseProductionNamedInput(production)) {
+        console.error('nx.json namedInputs.production must enumerate precise production inputs. Do not include default or broad {projectRoot}/** globs; use language/tool-specific paths such as {projectRoot}/src/**/*, {projectRoot}/Cargo.toml, or {projectRoot}/pyproject.toml.');
+        failures++;
+    }
+    return failures;
+}
+function isPreciseProductionNamedInput(production) {
+    let hasPositiveProjectInput = false;
+    for (const input of production) {
+        if (typeof input !== 'string') {
+            return false;
+        }
+        const normalized = input.startsWith('!') ? input.slice(1) : input;
+        if (impreciseProductionInputs.has(input) || impreciseProductionInputs.has(normalized)) {
+            return false;
+        }
+        if (!input.startsWith('!') && normalized.startsWith('{projectRoot}/')) {
+            hasPositiveProjectInput = true;
+        }
+    }
+    return hasPositiveProjectInput;
+}
+function removeColonTargetDefaults(nxJson) {
+    const targetDefaults = recordProperty(nxJson, 'targetDefaults');
+    if (!targetDefaults) {
+        return false;
+    }
+    let changed = false;
+    for (const targetName of Object.keys(targetDefaults)) {
+        if (targetName.includes(':')) {
+            delete targetDefaults[targetName];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function rewriteColonTargetDependenciesInPackage(pkg, resolvedTargets) {
+    const nx = recordProperty(pkg, 'nx');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    if (!targets) {
+        return false;
+    }
+    const projectName = packageNxProjectName(pkg);
+    const scriptTargetAliases = scriptTargetAliasesForProject(pkg, projectName);
+    let changed = false;
+    for (const target of Object.values(targets)) {
+        if (!isRecord(target) || !Array.isArray(target.dependsOn)) {
+            continue;
+        }
+        target.dependsOn = target.dependsOn.map((dependency) => {
+            if (typeof dependency !== 'string' || !dependency.includes(':')) {
+                return dependency;
+            }
+            const next = scriptTargetAliases.get(dependency) ?? replacementTargetName(dependency, null, resolvedTargets);
+            if (!next) {
+                return dependency;
+            }
+            changed = true;
+            return next;
+        });
+    }
+    return changed;
+}
+function scriptTargetAliasesForProject(pkg, projectName) {
+    if (!projectName) {
+        return new Map();
+    }
+    const scripts = recordProperty(pkg, 'scripts');
+    if (!scripts) {
+        return new Map();
+    }
+    const aliases = new Map();
+    for (const [scriptName, rawCommand] of Object.entries(scripts)) {
+        if (typeof rawCommand !== 'string' || !scriptName.includes(':')) {
+            continue;
+        }
+        const alias = parseNxRunAlias(rawCommand);
+        if (alias?.projectName === projectName && !alias.targetName.includes(':')) {
+            aliases.set(scriptName, alias.targetName);
+        }
+    }
+    return aliases;
+}
+function removePackageColonTargets(pkg) {
+    const nx = recordProperty(pkg, 'nx');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    if (!targets) {
+        return false;
+    }
+    let changed = false;
+    for (const targetName of Object.keys(targets)) {
+        if (targetName.includes(':')) {
+            delete targets[targetName];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function resolvedProjectTargetNames(resolvedProject) {
+    if (!resolvedProject) {
+        return undefined;
+    }
+    return isResolvedProjectTargets(resolvedProject) ? resolvedProject.targets : resolvedProject;
+}
+function resolvedProjectBuildDependsOn(resolvedProject) {
+    if (!isResolvedProjectTargets(resolvedProject)) {
+        return undefined;
+    }
+    return resolvedProject.buildDependsOn;
+}
+function isResolvedProjectTargets(value) {
+    return isRecord(value) && value.targets instanceof Set;
+}
+function removeRedundantNoopBuildTarget(pkg, resolvedProject) {
+    const resolvedTargets = resolvedProjectTargetNames(resolvedProject);
+    const resolvedBuildDependsOn = resolvedProjectBuildDependsOn(resolvedProject);
+    if (!resolvedTargets?.has('build') || !resolvedBuildDependsOn) {
+        return false;
+    }
+    const nx = recordProperty(pkg, 'nx');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    const build = targets ? recordProperty(targets, 'build') : null;
+    if (!targets ||
+        !build ||
+        !isNoopTarget(build) ||
+        !targetDependenciesMatchResolvedBuild(build, resolvedBuildDependsOn)) {
+        return false;
+    }
+    delete targets.build;
+    return true;
+}
+function isNoopTarget(target) {
+    const executor = stringProperty(target, 'executor');
+    if (executor !== null && executor !== 'nx:noop') {
+        return false;
+    }
+    const options = recordProperty(target, 'options');
+    return !options || stringProperty(options, 'command') === null;
+}
+function targetDependenciesMatchResolvedBuild(target, resolvedBuildDependsOn) {
+    if (!Array.isArray(target.dependsOn)) {
+        return false;
+    }
+    const expected = new Set(resolvedBuildDependsOn);
+    if (target.dependsOn.length !== expected.size) {
+        return false;
+    }
+    return target.dependsOn.every((dependency) => {
+        if (typeof dependency !== 'string') {
+            return false;
+        }
+        return expected.has(dependency);
+    });
+}
+function migratePackageColonTargets(pkg, resolvedTargets) {
+    const nx = recordProperty(pkg, 'nx');
+    const targets = nx ? recordProperty(nx, 'targets') : null;
+    if (!targets) {
+        return false;
+    }
+    const projectName = packageNxProjectName(pkg);
+    const scripts = recordProperty(pkg, 'scripts');
+    let changed = false;
+    const renamedTargets = new Map();
+    for (const [targetName, rawTarget] of Object.entries(targets)) {
+        if (!targetName.includes(':') || !isRecord(rawTarget)) {
+            continue;
+        }
+        const nextTargetName = replacementTargetName(targetName, targetCommand(rawTarget), resolvedTargets);
+        if (!nextTargetName || nextTargetName.includes(':')) {
+            continue;
+        }
+        if (!targetExistsInResolvedProject(nextTargetName, resolvedTargets)) {
+            targets[nextTargetName] = rawTarget;
+        }
+        delete targets[targetName];
+        renamedTargets.set(targetName, nextTargetName);
+        changed = true;
+    }
+    if (renamedTargets.size === 0) {
+        return changed;
+    }
+    for (const target of Object.values(targets)) {
+        if (isRecord(target)) {
+            changed = rewriteTargetDependencies(target, renamedTargets) || changed;
+        }
+    }
+    if (scripts && projectName) {
+        for (const [scriptName, rawCommand] of Object.entries(scripts)) {
+            if (typeof rawCommand !== 'string') {
+                continue;
+            }
+            const alias = parseNxRunAlias(rawCommand);
+            if (!alias || alias.projectName !== projectName) {
+                continue;
+            }
+            const nextTargetName = renamedTargets.get(alias.targetName);
+            if (!nextTargetName) {
+                continue;
+            }
+            scripts[scriptName] = nxRunAlias(projectName, nextTargetName, isContinuousTarget(nextTargetName, ''));
+            changed = true;
+        }
+    }
+    return changed;
+}
+function rewriteTargetDependencies(target, renamedTargets) {
+    if (!Array.isArray(target.dependsOn)) {
+        return false;
+    }
+    let changed = false;
+    target.dependsOn = target.dependsOn.map((dependency) => {
+        if (typeof dependency !== 'string') {
+            return dependency;
+        }
+        const next = renamedTargets.get(dependency);
+        if (!next) {
+            return dependency;
+        }
+        changed = true;
+        return next;
+    });
+    return changed;
+}
+function targetCommand(target) {
+    const options = recordProperty(target, 'options');
+    return options ? stringProperty(options, 'command') : null;
+}
+function replacementTargetName(targetName, command, resolvedTargets) {
+    if (command) {
+        const commandTargetName = targetNameForCommand(command);
+        if (commandTargetName) {
+            return commandTargetName;
+        }
+    }
+    const suffix = targetName.slice(targetName.lastIndexOf(':') + 1);
+    if (suffix && targetExistsInResolvedProject(suffix, resolvedTargets)) {
+        return suffix;
+    }
+    const dashed = targetName.replaceAll(':', '-');
+    if (targetExistsInResolvedProject(dashed, resolvedTargets)) {
+        return dashed;
+    }
+    return null;
+}
+function expectedNxJsTypescriptPlugin() {
+    return {
+        plugin: nxJsTypescriptPlugin,
+        options: {
+            typecheck: { targetName: 'typecheck' },
+            build: {
+                targetName: 'tsc-js',
+                configName: 'tsconfig.lib.json',
+                buildDepsName: 'build-deps',
+                watchDepsName: 'watch-deps',
+            },
+        },
+    };
+}
+function upsertNxPlugin(plugins, plugin) {
+    const pluginName = typeof plugin === 'string' ? plugin : stringProperty(plugin, 'plugin');
+    const next = plugins.filter((entry) => nxPluginName(entry) !== pluginName);
+    next.push(plugin);
+    return next;
+}
+function nxPluginName(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    return isRecord(value) ? stringProperty(value, 'plugin') : null;
+}
+function isNxJsTypescriptPlugin(value) {
+    return isRecord(value) && stringProperty(value, 'plugin') === nxJsTypescriptPlugin;
+}
+function isSmoothBricksNxPluginRecord(value) {
+    return isRecord(value) && stringProperty(value, 'plugin') === smoothBricksNxPlugin;
+}
+function nxJsBuildTargetName(plugin) {
+    const options = recordProperty(plugin, 'options');
+    const build = options ? recordProperty(options, 'build') : null;
+    return build ? stringProperty(build, 'targetName') : null;
+}
+function applyPackageNxConfig(pkg, options) {
+    const nx = getOrCreateRecord(pkg, 'nx');
+    const changed = setStringProperty(nx, 'name', options.projectName);
+    const targets = options.targets === true ? getOrCreateRecord(nx, 'targets') : null;
+    return { nx, targets, changed };
+}
+function packageNxProjectName(pkg) {
+    const nx = recordProperty(pkg, 'nx');
+    return (nx ? stringProperty(nx, 'name') : null) ?? stringProperty(pkg, 'name');
+}
+function classifyScriptRewrite(scriptName, command) {
+    if (isNxRunAlias(command) || isBlockedScriptCommand(scriptName, command)) {
+        return null;
+    }
+    const parsed = parseEnvPrefixedCommand(command);
+    const targetName = rewriteTargetName(scriptName, parsed.command);
+    if (!targetName || !isSafeNxScriptCommand(parsed.command)) {
+        return null;
+    }
+    return {
+        targetName,
+        continuous: isContinuousTarget(targetName, parsed.command),
+        command: parsed.command,
+        env: parsed.env,
+    };
+}
+function rewriteTargetName(scriptName, command) {
+    return targetNameForCommand(command) ?? (scriptName.includes(':') ? null : scriptName);
+}
+function targetNameForCommand(command) {
+    const trimmed = command.trim();
+    if (/^tsc\s+--build\s+tsconfig\.lib\.json(?:\s|$)/.test(trimmed)) {
+        return 'tsc-js';
+    }
+    const zigStep = /^zig\s+build\s+([A-Za-z0-9_-]+)(?:\s|$)/.exec(trimmed)?.[1];
+    if (zigStep) {
+        return `zig-${zigStep}`;
+    }
+    if (/^wrangler\s+build(?:\s|$)/.test(trimmed)) {
+        return 'build';
+    }
+    return null;
+}
+function nxRunAlias(projectName, targetName, continuous) {
+    const flags = continuous ? ' --tui=false --outputStyle=stream' : '';
+    return `nx run ${projectName}:${targetName}${flags}`;
+}
+function expectedTargetDependencies(targetName) {
+    return targetName === 'preview' ? ['build'] : ['^build'];
+}
+function targetExistsInResolvedProject(targetName, resolvedTargets) {
+    return resolvedTargets?.has(targetName) === true;
+}
+function setStringArrayProperty(record, key, value) {
+    const current = record[key];
+    if (stringArrayEquals(current, value)) {
+        return false;
+    }
+    record[key] = value;
+    return true;
+}
+function stringArrayEquals(value, expected) {
+    return (Array.isArray(value) && value.length === expected.length && value.every((entry, index) => entry === expected[index]));
+}
+function targetDependsOn(target, expected) {
+    const dependsOn = target.dependsOn;
+    return Array.isArray(dependsOn) && expected.every((entry) => dependsOn.includes(entry));
+}
+function hasWorkspaceDependency(pkg, workspaceNames) {
+    for (const field of workspaceDependencyFields) {
+        const dependencies = recordProperty(pkg, field);
+        if (!dependencies) {
+            continue;
+        }
+        for (const name of Object.keys(dependencies)) {
+            if (workspaceNames.has(name)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isSafeNxScriptCommand(command) {
+    const trimmed = command.trim();
+    return (/^bun\s+test(?:\s|$)/.test(trimmed) ||
+        /^tsc-bun-test(?:\s|$)/.test(trimmed) ||
+        /^vitest(?:\s|$)/.test(trimmed) ||
+        /^tsc\s+(?:--build|--noEmit)(?:\s|$)/.test(trimmed) ||
+        /^tsdown(?:\s|$)/.test(trimmed) ||
+        /^vite\s+(?:build|dev|preview)(?:\s|$)/.test(trimmed) ||
+        /^astro\s+(?:build|dev|preview|check)(?:\s|$)/.test(trimmed) ||
+        /^zig\s+build(?:\s|$)/.test(trimmed) ||
+        /^bun\s+[./\w-]*build[\w.-]*\.ts(?:\s|$)/.test(trimmed) ||
+        /(?:^|\s)(?:bench|benchmark)(?:\s|$)/.test(trimmed) ||
+        /^wrangler\s+build(?:\s|$)/.test(trimmed));
+}
+function isBlockedScriptCommand(scriptName, command) {
+    if (/^(?:deploy|db|release|sync|subtree|publish|pack)(?::|$)/.test(scriptName)) {
+        return true;
+    }
+    const trimmed = parseEnvPrefixedCommand(command).command;
+    return /^(?:deploy|db|release|sync|subtree|publish|pack)(?:\s|$)/.test(trimmed) || trimmed === 'astro';
+}
+function parseEnvPrefixedCommand(command) {
+    const env = {};
+    let rest = command.trimStart();
+    while (true) {
+        const match = /^([A-Za-z_][A-Za-z0-9_]*)=/.exec(rest);
+        if (!match?.[1]) {
+            return { command: rest.trim(), env };
+        }
+        let index = match[0].length;
+        let value = '';
+        const quote = rest[index];
+        if (quote === '"' || quote === "'") {
+            index += 1;
+            const end = rest.indexOf(quote, index);
+            if (end === -1) {
+                return { command: command.trim(), env: {} };
+            }
+            value = rest.slice(index, end);
+            index = end + 1;
+        }
+        else {
+            const end = rest.slice(index).search(/\s/);
+            const valueEnd = end === -1 ? rest.length : index + end;
+            value = rest.slice(index, valueEnd);
+            index = valueEnd;
+        }
+        if (index < rest.length && !/\s/.test(rest[index] ?? '')) {
+            return { command: command.trim(), env: {} };
+        }
+        env[match[1]] = value;
+        rest = rest.slice(index).trimStart();
+    }
+}
+function isContinuousTarget(targetName, command) {
+    return (/(?:^|:|-)(?:dev|serve|preview|watch)(?:$|:|-)/.test(targetName) ||
+        /(?:^|\s)(?:dev|serve|preview|--watch|-w)(?:\s|$)/.test(command));
+}
+function isNxRunAlias(command) {
+    return /^nx\s+run\s+\S+:\S+/.test(command.trim());
+}
+function parseNxRunAlias(command) {
+    const match = /^nx\s+run\s+([^:\s]+):([^\s]+)(?:\s|$)/.exec(command.trim());
+    if (!match?.[1] || !match[2]) {
+        return null;
+    }
+    return { projectName: match[1], targetName: match[2] };
+}
+function recordKeysAreSorted(record) {
+    const keys = Object.keys(record);
+    return keys.every((key, index) => index === 0 || keys[index - 1] <= key);
+}
+function sortRecordInPlace(record) {
+    if (recordKeysAreSorted(record)) {
+        return false;
+    }
+    const entries = Object.entries(record).sort(([a], [b]) => a.localeCompare(b));
+    for (const key of Object.keys(record)) {
+        delete record[key];
+    }
+    for (const [key, value] of entries) {
+        record[key] = value;
+    }
+    return true;
+}
+function isScriptRunnerCommand(command, scriptName) {
+    if (!command) {
+        return false;
+    }
+    const escaped = escapeRegex(scriptName);
+    return new RegExp(`^(?:bun|npm)\\s+run\\s+${escaped}(?:\\s|$)`).test(command.trim());
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function suggestNxProjectName(rootPackageName, packageName) {
+    const rootScope = npmScope(rootPackageName);
+    if (!rootScope || npmScope(packageName) !== rootScope) {
+        return null;
+    }
+    return unscopedPackageName(packageName);
+}
+function npmScope(packageName) {
+    const match = /^(@[^/]+)\//.exec(packageName);
+    return match?.[1] ?? null;
+}
+function unscopedPackageName(packageName) {
+    return packageName.startsWith('@') ? packageName.slice(packageName.indexOf('/') + 1) : packageName;
+}
 function setBooleanProperty(record, key, value) {
     if (record[key] === value) {
         return false;