knip 6.40.0 → 6.42.0

package/dist/plugins/biome/index.js

@@ -10,9 +10,9 @@ const isRootConfigReference = (specifier) => specifier === '//';
 const resolveExtends = (extendsArray, options) => {
     return extendsArray.map(specifier => {
         if (isRootConfigReference(specifier)) {
-            return toConfig('biome', join(options.rootCwd, 'biome'), { containingFilePath: options.configFilePath });
+            return toConfig('biome', join(options.rootCwd, 'biome'));
         }
-        return toConfig('biome', specifier, { containingFilePath: options.configFilePath });
+        return toConfig('biome', specifier);
     });
 };
 const resolveConfig = (config, options) => {

package/dist/plugins/commitlint/index.js

@@ -25,12 +25,12 @@ const toPluginSpecifier = (id) => {
         return id;
     return id.replace('/', '/commitlint-plugin-');
 };
-const resolveConfig = async (config, options) => {
+const resolveConfig = async (config) => {
     const inputs = [];
     const extendsConfigs = [];
     for (const id of config.extends ? [config.extends].flat() : []) {
         if (isInternal(id))
-            inputs.push(toConfig('commitlint', id, { containingFilePath: options.configFilePath }));
+            inputs.push(toConfig('commitlint', id));
         else
             extendsConfigs.push(toExtendsSpecifier(id));
     }

package/dist/plugins/eslint/helpers.js

@@ -20,7 +20,7 @@ const getInputsDeprecated = (config, options) => {
     const extendsSpecifiers = compact(extendsList.map(resolveExtendSpecifier));
     if (extendsSpecifiers.some(specifier => specifier?.startsWith('eslint-plugin-prettier')))
         extendsSpecifiers.push('eslint-config-prettier');
-    const extendConfigs = [...extendsList.filter(isInternal), ...extendsSpecifiers].map(specifier => toConfig('eslint', specifier, { containingFilePath: options.configFilePath }));
+    const extendConfigs = [...extendsList.filter(isInternal), ...extendsSpecifiers].map(specifier => toConfig('eslint', specifier));
     const plugins = config.plugins ? config.plugins.map(resolvePluginSpecifier) : [];
     const parsers = getParsers(config);
     const babelDependencies = config.parserOptions?.babelOptions

package/dist/plugins/expo/helpers.js

@@ -50,7 +50,7 @@ export const getDependencies = async (localConfig, options) => {
     if (platforms.includes('web')) {
         inputs.add(toProductionDependency('react-native-web'));
         inputs.add(toProductionDependency('react-dom'));
-        if (!isExpoRouter) {
+        if (!isExpoRouter && !options.enabledPlugins.includes('expo-router')) {
             inputs.add(toDependency('@expo/metro-runtime'));
         }
     }

package/dist/plugins/expo/index.js

@@ -1,37 +1,17 @@
-import { toConfig, toIgnore, toProductionEntry } from '../../util/input.js';
-import { join } from '../../util/path.js';
+import { toConfig, toIgnore } from '../../util/input.js';
 import { hasDependency } from '../../util/plugin.js';
-import { getConfig, getDependencies } from './helpers.js';
+import { getDependencies } from './helpers.js';
 const title = 'Expo';
 const enablers = ['expo'];
 const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
-const config = ['app.json', 'app.config.{ts,js}'];
-const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
+const config = ['app.json', 'app.config.{json,ts,js,mts,cts,mjs,cjs}'];
 const resolve = () => [toConfig('babel', 'babel.config'), toIgnore('babel-preset-expo', 'unresolved')];
-const resolveConfig = async (localConfig, options) => {
-    const { manifest } = options;
-    const config = getConfig(localConfig, options);
-    if (manifest.main === 'expo-router/entry') {
-        let patterns = [...production];
-        const normalizedPlugins = config.plugins?.map(plugin => (Array.isArray(plugin) ? plugin : [plugin])) ?? [];
-        const expoRouterPlugin = normalizedPlugins.find(([plugin]) => plugin === 'expo-router');
-        if (expoRouterPlugin) {
-            const [, options] = expoRouterPlugin;
-            if (typeof options?.root === 'string') {
-                patterns = [join(options.root, '**/*.{js,jsx,ts,tsx}')];
-            }
-        }
-        return patterns.map(entry => toProductionEntry(entry)).concat(await getDependencies(localConfig, options));
-    }
-    return production.map(entry => toProductionEntry(entry)).concat(await getDependencies(localConfig, options));
-};
 const plugin = {
     title,
     enablers,
     isEnabled,
     config,
-    production,
     resolve,
-    resolveConfig,
+    resolveConfig: getDependencies,
 };
 export default plugin;

package/dist/plugins/expo-router/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/expo-router/index.js

@@ -0,0 +1,32 @@
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import expo from '../expo/index.js';
+import { getConfig } from '../expo/helpers.js';
+const title = 'Expo Router';
+const enablers = ['expo-router'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = expo.config;
+const production = ['app/**/*.{js,jsx,ts,tsx}', 'src/app/**/*.{js,jsx,ts,tsx}'];
+const resolveConfig = async (localConfig, options) => {
+    const config = getConfig(localConfig, options);
+    for (const plugin of config.plugins ?? []) {
+        if (!Array.isArray(plugin))
+            continue;
+        const [name, pluginOptions] = plugin;
+        const root = pluginOptions?.root;
+        if (name === 'expo-router' && typeof root === 'string') {
+            return [toProductionEntry(join(root, '**/*.{js,jsx,ts,tsx}'))];
+        }
+    }
+    return production.map(id => toProductionEntry(id));
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveConfig,
+};
+export default plugin;

package/dist/plugins/filesystem-routing/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/filesystem-routing/index.js

@@ -0,0 +1,57 @@
+import { escapePath } from 'tinyglobby';
+import { findImportedCalls, findProperty } from '../../typescript/ast-helpers.js';
+import { getStringValue } from '../../typescript/ast-nodes.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join, relative, toAbsolute } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+import { getViteRoot } from '../vite/helpers.js';
+const title = 'filesystem-routing';
+const enablers = ['filesystem-routing'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['vite.config.{js,mjs,ts,cjs,mts,cts}'];
+const defaultDir = 'src/routes';
+const defaultExtensions = ['js', 'jsx', 'ts', 'tsx', 'tsrx'];
+const production = [`${defaultDir}/**/*.{${defaultExtensions.join(',')}}`];
+const resolveFromAST = (program, { config, cwd }) => {
+    if (config.entry)
+        return [];
+    const root = getViteRoot(program, cwd);
+    const toEntry = (dir, pattern) => toProductionEntry(join(cwd, escapePath(relative(cwd, dir)), pattern));
+    const calls = findImportedCalls(program, 'filesystem-routing/vite');
+    if (calls.length === 0)
+        return production.map(pattern => toEntry(root, pattern));
+    const inputs = [];
+    for (const call of calls) {
+        const options = call.arguments[0];
+        const dir = getStringValue(findProperty(options, 'dir')) ?? defaultDir;
+        const value = findProperty(options, 'extensions');
+        const extensions = new Set();
+        let useDefaults = value?.type !== 'ArrayExpression';
+        if (value?.type === 'ArrayExpression') {
+            for (const element of value.elements) {
+                const extension = getStringValue(element);
+                if (extension === undefined)
+                    useDefaults = true;
+                else
+                    extensions.add(extension);
+            }
+        }
+        if (useDefaults)
+            for (const extension of defaultExtensions)
+                extensions.add(extension);
+        if (extensions.size === 0)
+            continue;
+        const suffix = extensions.size === 1 ? [...extensions][0] : `{${[...extensions].join(',')}}`;
+        inputs.push(toEntry(toAbsolute(dir, root), `**/*.${suffix}`));
+    }
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/flue/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from '../../types/config.ts';
+declare const plugin: Plugin;
+export default plugin;

package/dist/plugins/flue/index.js

@@ -0,0 +1,42 @@
+import { collectFirstPropertyValue } from '../../typescript/ast-helpers.js';
+import { isDirectory } from '../../util/fs.js';
+import { toProductionEntry } from '../../util/input.js';
+import { join } from '../../util/path.js';
+import { hasDependency } from '../../util/plugin.js';
+const title = 'Flue';
+const enablers = ['@flue/runtime'];
+const isEnabled = ({ dependencies }) => hasDependency(dependencies, enablers);
+const config = ['flue.config.{ts,mts,mjs,js,cjs,cts}'];
+const extensions = '{ts,mts,js,mjs}';
+const entryNames = ['app', 'db', 'cloudflare'];
+const agentsPattern = `{agent,agents/*,agents/*/agent}.${extensions}`;
+const production = [`{.flue/,src/,}{app,db,cloudflare}.${extensions}`, `{.flue/,src/,}${agentsPattern}`];
+const getSourceRoot = (dir) => {
+    for (const name of ['.flue', 'src'])
+        if (isDirectory(dir, name))
+            return join(dir, name);
+    return dir;
+};
+const resolveFromAST = (program, { configFileDir }) => {
+    const sourceRoot = getSourceRoot(configFileDir);
+    const inputs = [];
+    for (const name of entryNames) {
+        const filePath = collectFirstPropertyValue(program, name);
+        if (filePath)
+            inputs.push(toProductionEntry(join(configFileDir, filePath)));
+        else
+            inputs.push(toProductionEntry(join(sourceRoot, `${name}.${extensions}`)));
+    }
+    const agents = collectFirstPropertyValue(program, 'agents') ?? agentsPattern;
+    inputs.push(toProductionEntry(join(sourceRoot, agents)));
+    return inputs;
+};
+const plugin = {
+    title,
+    enablers,
+    isEnabled,
+    config,
+    production,
+    resolveFromAST,
+};
+export default plugin;

package/dist/plugins/github-actions/index.js

@@ -29,7 +29,7 @@ const resolveConfig = async (config, options) => {
         const path = action?.with?.path;
         for (const step of steps.steps) {
             const workingDir = step['working-directory'];
-            const dir = join(rootCwd, path && workingDir ? relative(workingDir, path) : workingDir ? workingDir : '.');
+            const dir = join(rootCwd, path && workingDir ? relative(path, workingDir) : workingDir ? workingDir : '.');
             if (step.run) {
                 const manifest = getManifest(dir) ?? options.manifest;
                 const actionPath = relative(dir, configFileDir);

package/dist/plugins/index.d.ts

@@ -35,6 +35,7 @@ export declare const Plugins: {
     eve: import("../types/config.ts").Plugin;
     execa: import("../types/config.ts").Plugin;
     expo: import("../types/config.ts").Plugin;
+    'expo-router': import("../types/config.ts").Plugin;
     'expressive-code': {
         title: string;
         enablers: string[];
@@ -42,6 +43,8 @@ export declare const Plugins: {
         config: string[];
     };
     fast: import("../types/config.ts").Plugin;
+    'filesystem-routing': import("../types/config.ts").Plugin;
+    flue: import("../types/config.ts").Plugin;
     fumadocs: import("../types/config.ts").Plugin;
     gatsby: import("../types/config.ts").Plugin;
     'github-action': import("../types/config.ts").Plugin;
@@ -135,6 +138,7 @@ export declare const Plugins: {
     'serverless-framework': import("../types/config.ts").Plugin;
     'simple-git-hooks': import("../types/config.ts").Plugin;
     'size-limit': import("../types/config.ts").Plugin;
+    'solidjs-vite-plugin': import("../types/config.ts").Plugin;
     sst: import("../types/config.ts").Plugin;
     starlight: import("../types/config.ts").Plugin;
     stencil: import("../types/config.ts").Plugin;
@@ -158,6 +162,7 @@ export declare const Plugins: {
     'ts-node': import("../types/config.ts").Plugin;
     tsd: import("../types/config.ts").Plugin;
     tsdown: import("../types/config.ts").Plugin;
+    tsrs: import("../types/config.ts").Plugin;
     tsup: import("../types/config.ts").Plugin;
     tsx: import("../types/config.ts").Plugin;
     turbo: import("../types/config.ts").Plugin;

package/dist/plugins/index.js

@@ -34,8 +34,11 @@ import { default as eslint } from './eslint/index.js';
 import { default as eve } from './eve/index.js';
 import { default as execa } from './execa/index.js';
 import { default as expo } from './expo/index.js';
+import { default as expoRouter } from './expo-router/index.js';
 import { default as expressiveCode } from './expressive-code/index.js';
 import { default as fast } from './fast/index.js';
+import { default as filesystemRouting } from './filesystem-routing/index.js';
+import { default as flue } from './flue/index.js';
 import { default as fumadocs } from './fumadocs/index.js';
 import { default as gatsby } from './gatsby/index.js';
 import { default as githubAction } from './github-action/index.js';
@@ -129,6 +132,7 @@ import { default as sentry } from './sentry/index.js';
 import { default as serverlessFramework } from './serverless-framework/index.js';
 import { default as simpleGitHooks } from './simple-git-hooks/index.js';
 import { default as sizeLimit } from './size-limit/index.js';
+import { default as solidjsVitePlugin } from './solidjs-vite-plugin/index.js';
 import { default as sst } from './sst/index.js';
 import { default as starlight } from './starlight/index.js';
 import { default as stencil } from './stencil/index.js';
@@ -152,6 +156,7 @@ import { default as travis } from './travis/index.js';
 import { default as tsNode } from './ts-node/index.js';
 import { default as tsd } from './tsd/index.js';
 import { default as tsdown } from './tsdown/index.js';
+import { default as tsrs } from './tsrs/index.js';
 import { default as tsup } from './tsup/index.js';
 import { default as tsx } from './tsx/index.js';
 import { default as turbo } from './turbo/index.js';
@@ -225,8 +230,11 @@ export const Plugins = {
     eve,
     execa,
     expo,
+    'expo-router': expoRouter,
     'expressive-code': expressiveCode,
     fast,
+    'filesystem-routing': filesystemRouting,
+    flue,
     fumadocs,
     gatsby,
     'github-action': githubAction,
@@ -320,6 +328,7 @@ export const Plugins = {
     'serverless-framework': serverlessFramework,
     'simple-git-hooks': simpleGitHooks,
     'size-limit': sizeLimit,
+    'solidjs-vite-plugin': solidjsVitePlugin,
     sst,
     starlight,
     stencil,
@@ -343,6 +352,7 @@ export const Plugins = {
     'ts-node': tsNode,
     tsd,
     tsdown,
+    tsrs,
     tsup,
     tsx,
     turbo,

package/dist/plugins/jest/index.js

@@ -5,6 +5,7 @@ import { isInternal, join, normalize, toAbsolute } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { getDependenciesFromConfig } from '../babel/index.js';
 import { getReportersDependencies, resolveExtensibleConfig, resolveWithPrefix } from './helpers.js';
+import { createJestMockVisitor } from './visitors/mock.js';
 const title = 'Jest';
 const enablers = ['jest'];
 const isEnabled = ({ dependencies, manifest }) => hasDependency(dependencies, enablers) || Boolean(manifest.name?.startsWith('jest-presets'));
@@ -127,6 +128,9 @@ const resolveConfig = async (localConfig, options) => {
 const args = {
     config: true,
 };
+const registerVisitors = ({ ctx, registerVisitor }) => {
+    registerVisitor(createJestMockVisitor(ctx));
+};
 const plugin = {
     title,
     enablers,
@@ -135,5 +139,6 @@ const plugin = {
     entry,
     resolveConfig,
     args,
+    registerVisitors,
 };
 export default plugin;

package/dist/plugins/jest/visitors/mock.d.ts

@@ -0,0 +1,2 @@
+import type { PluginVisitorContext, PluginVisitorObject } from '../../../types/config.ts';
+export declare function createJestMockVisitor(ctx: PluginVisitorContext): PluginVisitorObject;

package/dist/plugins/jest/visitors/mock.js

@@ -0,0 +1,91 @@
+import { IMPORT_FLAGS } from '../../../constants.js';
+import { getPropertyKey } from '../../../typescript/ast-helpers.js';
+import { getStringValue, isStringLiteral } from '../../../typescript/ast-nodes.js';
+import { isShadowed } from '../../../typescript/visitors/walk.js';
+const mockMethods = new Set([
+    'mock',
+    'doMock',
+    'requireActual',
+    'requireMock',
+    'createMockFromModule',
+    'unmock',
+    'dontMock',
+    'deepUnmock',
+    'setMock',
+    'unstable_mockModule',
+    'unstable_unmockModule',
+]);
+export function createJestMockVisitor(ctx) {
+    const jestNames = new Set();
+    const virtualMocks = new Set();
+    const virtualEsmMocks = new Set();
+    const mockLookups = [];
+    return {
+        Program(node) {
+            jestNames.clear();
+            virtualMocks.clear();
+            virtualEsmMocks.clear();
+            mockLookups.length = 0;
+            jestNames.add('jest');
+            for (const statement of node.body) {
+                if (statement.type !== 'ImportDeclaration' ||
+                    !isStringLiteral(statement.source) ||
+                    getStringValue(statement.source) !== '@jest/globals')
+                    continue;
+                for (const specifier of statement.specifiers ?? []) {
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifier.imported.type === 'Identifier' &&
+                        specifier.imported.name === 'jest') {
+                        jestNames.add(specifier.local.name);
+                    }
+                }
+            }
+        },
+        CallExpression(node) {
+            const argument = node.arguments[0];
+            const callee = node.callee;
+            if (!isStringLiteral(argument) ||
+                callee.type !== 'MemberExpression' ||
+                callee.computed ||
+                callee.object.type !== 'Identifier' ||
+                !jestNames.has(callee.object.name) ||
+                isShadowed(callee.object.name, callee.object.start) ||
+                callee.property.type !== 'Identifier' ||
+                !mockMethods.has(callee.property.name))
+                return;
+            const specifier = getStringValue(argument);
+            const method = callee.property.name;
+            const options = node.arguments[2];
+            if ((method === 'mock' || method === 'doMock' || method === 'unstable_mockModule') &&
+                options?.type === 'ObjectExpression') {
+                for (const property of options.properties) {
+                    if (property.type === 'Property' &&
+                        !property.computed &&
+                        getPropertyKey(property) === 'virtual' &&
+                        property.value.type === 'Literal' &&
+                        property.value.value === true) {
+                        (method === 'unstable_mockModule' ? virtualEsmMocks : virtualMocks).add(specifier);
+                        return;
+                    }
+                }
+            }
+            if (method === 'requireActual' || method === 'createMockFromModule') {
+                const flags = method === 'requireActual' ? IMPORT_FLAGS.OPAQUE : IMPORT_FLAGS.SIDE_EFFECTS;
+                ctx.addImport(specifier, argument.start, flags);
+                return;
+            }
+            mockLookups.push({
+                specifier,
+                pos: argument.start,
+                isEsm: method === 'unstable_mockModule' || method === 'unstable_unmockModule',
+            });
+        },
+        'Program:exit'() {
+            for (const { specifier, pos, isEsm } of mockLookups) {
+                if ((isEsm ? virtualEsmMocks : virtualMocks).has(specifier))
+                    continue;
+                ctx.addImport(specifier, pos, IMPORT_FLAGS.SIDE_EFFECTS);
+            }
+        },
+    };
+}

package/dist/plugins/mise/scripts.js

@@ -1,4 +1,4 @@
-import { parse } from 'unbash';
+import { forEachChild, parse } from 'unbash';
 import { getDependenciesFromCommand, getInputsFromNodeOptions } from '../../binaries/command.js';
 import { spawningBinaries } from '../../binaries/fallback.js';
 import { isWrapper } from '../../binaries/plugins.js';
@@ -7,99 +7,79 @@ import { toScript } from '../../binaries/util.js';
 import { SCRIPT_INTERPOLATION } from '../../constants.js';
 import { isBinary } from '../../util/input.js';
 import { extractBinary, isRelativeNodeModulesBin } from '../../util/modules.js';
-import { walkCommands } from '../../util/scripts.js';
+import { isScriptExpansion, collectCommands } from '../../util/scripts.js';
 export const getInputsFromMiseScript = (script, options, hasLocalBinPath) => {
     const inputs = [];
     const definedFunctions = new Set();
-    const readParts = (parts) => {
+    const readCommand = (command, source) => {
         let text = '';
-        let value = '';
-        let hasExpansion = false;
-        for (const part of parts) {
-            if (part.type === 'CommandExpansion' || part.type === 'ProcessSubstitution') {
-                if (part.script)
-                    readScript(part.script);
-                text += SCRIPT_INTERPOLATION;
-                value += SCRIPT_INTERPOLATION;
-                hasExpansion = true;
+        let cursor = command.pos;
+        const visit = (node) => {
+            if (!isScriptExpansion(node)) {
+                forEachChild(node, visit);
+                return;
             }
-            else if (part.type === 'DoubleQuoted' || part.type === 'LocaleString') {
-                const inner = readParts(part.parts);
-                text += `${part.type === 'LocaleString' ? '$"' : '"'}${inner.text}"`;
-                value += inner.value;
-                if (inner.hasExpansion)
-                    hasExpansion = true;
+            if (node.script)
+                readScript(node.script, node.script.source ?? source);
+            if (node.pos >= cursor && node.end <= command.end) {
+                text += source.slice(cursor, node.pos) + SCRIPT_INTERPOLATION;
+                cursor = node.end;
             }
-            else {
-                text += part.text;
-                value += 'value' in part ? part.value : part.text;
-            }
-        }
-        return { text, value, hasExpansion };
-    };
-    const readWord = (word) => {
-        if (!word.parts)
-            return word;
-        const { text, value, hasExpansion } = readParts(word.parts);
-        return hasExpansion ? { ...word, text, value } : word;
+        };
+        forEachChild(command, visit);
+        return text + source.slice(cursor, command.end);
     };
-    const readScript = (parsed) => {
+    const readScript = (parsed, source) => {
         for (const statement of parsed.commands) {
             if (statement.command.type === 'Function')
                 definedFunctions.add(statement.command.name.value);
         }
-        for (const statement of parsed.commands) {
-            for (const command of walkCommands(statement.command)) {
-                const name = command.name?.value;
-                const word = command.name && readWord(command.name);
-                const prefix = command.prefix.map(assignment => {
-                    const value = assignment.value && readWord(assignment.value);
-                    return value && value !== assignment.value
-                        ? { ...assignment, value, text: `${assignment.name}=${value.text}` }
-                        : assignment;
-                });
-                const words = command.suffix.map(readWord);
-                if (!name || !word || definedFunctions.has(name))
+        for (const command of collectCommands(parsed)) {
+            const text = readCommand(command, source);
+            const name = command.name?.value;
+            if (!name || definedFunctions.has(name))
+                continue;
+            const binary = extractBinary(name);
+            const isPackageCommand = isPackageManager(binary);
+            const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
+            const hasPath = command.prefix.some(item => item.type === 'Assignment' && item.name === 'PATH');
+            const isLocal = hasLocalBinPath && !hasPath;
+            const isWrapperCommand = !isPackageCommand && isWrapper(binary);
+            if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                continue;
+            let commandInputs;
+            if (isWrapperCommand || binary === 'find') {
+                const [marked] = collectCommands(parse(text));
+                if (!marked)
                     continue;
-                const binary = extractBinary(name);
-                const isPackageCommand = isPackageManager(binary);
-                const isExplicit = isPackageCommand || name.startsWith('./') || isRelativeNodeModulesBin(name);
-                const isLocal = hasLocalBinPath && !command.prefix.some(assignment => assignment.name === 'PATH');
-                const isWrapperCommand = !isPackageCommand && isWrapper(binary);
-                if (!isExplicit && !isLocal && !isWrapperCommand && binary !== 'node' && binary !== 'find')
+                const fromScript = (script) => {
+                    inputs.push(...getInputsFromMiseScript(script, options, isLocal));
+                    return [];
+                };
+                const fromArgs = args => fromScript(toScript(args));
+                commandInputs = getDependenciesFromCommand(marked, { ...options, fromArgs });
+                if (spawningBinaries.includes(binary))
+                    commandInputs.push(...getInputsFromNodeOptions(marked.prefix));
+            }
+            else {
+                commandInputs = options.getInputsFromScripts(text, { cwd: options.cwd, manifest: options.manifest });
+            }
+            if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                continue;
+            const binaryInput = commandInputs.find(input => isBinary(input) && input.specifier === binary);
+            if (!isExplicit && isLocal && binaryInput)
+                binaryInput.optional = true;
+            for (const input of commandInputs) {
+                if (!input.specifier || input.specifier.includes(SCRIPT_INTERPOLATION))
                     continue;
-                let commandInputs;
-                if (isWrapperCommand || binary === 'find') {
-                    const fromScript = (script) => {
-                        inputs.push(...getInputsFromMiseScript(script, options, isLocal));
-                        return [];
-                    };
-                    const fromArgs = args => fromScript(toScript(args));
-                    commandInputs = getDependenciesFromCommand({ ...command, name: word, prefix, suffix: words }, { ...options, fromArgs });
-                }
-                else {
-                    commandInputs = options.getInputsFromScripts([...prefix.map(assignment => assignment.text), word.text, ...words.map(word => word.text)].join(' '), { cwd: options.cwd, manifest: options.manifest });
-                }
-                if (!isExplicit && !isLocal && binary !== 'node' && binary !== 'find')
+                if (!isExplicit && !isLocal && input === binaryInput)
                     continue;
-                if (isWrapperCommand && spawningBinaries.includes(binary)) {
-                    commandInputs.push(...getInputsFromNodeOptions(prefix));
-                }
-                const binaryInput = commandInputs.find(input => isBinary(input) && input.specifier === binary);
-                if (!isExplicit && isLocal && binaryInput)
-                    binaryInput.optional = true;
-                for (const input of commandInputs) {
-                    if (!input.specifier || input.specifier.includes(SCRIPT_INTERPOLATION))
-                        continue;
-                    if (!isExplicit && !isLocal && input === binaryInput)
-                        continue;
-                    inputs.push(input);
-                }
+                inputs.push(input);
             }
         }
     };
     try {
-        readScript(parse(script));
+        readScript(parse(script), script);
     }
     catch {
         return [];

package/dist/plugins/moonrepo/index.js

@@ -1,3 +1,4 @@
+import { relative } from '../../util/path.js';
 import { hasDependency } from '../../util/plugin.js';
 import { toShellCommand } from '../../util/scripts.js';
 const title = 'moonrepo';
@@ -7,7 +8,7 @@ const isRootOnly = true;
 const config = ['moon.yml', '.moon/tasks.yml', '.moon/tasks/*.yml'];
 const resolveConfig = async (config, options) => {
     const tasks = config.tasks ? Object.values(config.tasks) : [];
-    const expand = (value) => value.replace('$workspaceRoot', options.rootCwd).replace('$projectRoot', options.cwd);
+    const expand = (value) => value.replace('$workspaceRoot', relative(options.cwd, options.rootCwd)).replace('$projectRoot', '.');
     const inputs = tasks
         .map(task => task.command)
         .filter(command => command)