agentic-workflow-manager 8.1.1 → 8.1.2

package/dist/src/commands/sensors/compatibility/contract.js

@@ -206,7 +206,7 @@ function parseVariant(input, source, location) {
         invalid(source, `${location} requires requirements and probe when policyRef is absent`);
     const requirements = policy ? undefined : record(value.requirements, source, `${location}.requirements`);
     if (requirements)
-        fields(requirements, ['tool', 'toolRange', 'runtime', 'runtimeRange', 'configFiles'], source, `${location}.requirements`);
+        fields(requirements, ['tool', 'toolRange', 'runtime', 'runtimeRange', 'configFiles', 'packageJsonFields'], source, `${location}.requirements`);
     const toolRange = policy?.toolRange ?? text(requirements.toolRange, source, `${location}.requirements.toolRange`);
     const runtimeRange = policy?.runtimeRange ?? text(requirements.runtimeRange, source, `${location}.requirements.runtimeRange`);
     if (semver_1.default.validRange(toolRange) === null || semver_1.default.validRange(runtimeRange) === null)
@@ -223,7 +223,8 @@ function parseVariant(input, source, location) {
         certifiedRange,
         requirements: policy
             ? { tool: policy.tool, toolRange, runtime: policy.runtime, runtimeRange }
-            : { tool: text(requirements.tool, source, `${location}.requirements.tool`), toolRange, runtime: text(requirements.runtime, source, `${location}.requirements.runtime`), runtimeRange, ...('configFiles' in requirements ? { configFiles: stringArray(requirements.configFiles, source, `${location}.requirements.configFiles`).map((file, index) => asset(file, source, `${location}.requirements.configFiles[${index}]`)) } : {}) },
+            : { tool: text(requirements.tool, source, `${location}.requirements.tool`), toolRange, runtime: text(requirements.runtime, source, `${location}.requirements.runtime`), runtimeRange, ...('configFiles' in requirements ? { configFiles: stringArray(requirements.configFiles, source, `${location}.requirements.configFiles`).map((file, index) => asset(file, source, `${location}.requirements.configFiles[${index}]`)) } : {}), ...('packageJsonFields' in requirements ? { packageJsonFields: stringArray(requirements.packageJsonFields, source, `${location}.requirements.packageJsonFields`).map((field, index) => { if (!/^[A-Za-z][A-Za-z0-9]*$/.test(field))
+                        invalid(source, `${location}.requirements.packageJsonFields[${index}] must be a stable package.json field`); return field; }) } : {}) },
         assets: assetArray(value.assets, source, `${location}.assets`, true),
         formatter: text(value.formatter, source, `${location}.formatter`),
         probe: { kind: policy?.probe ?? probe.kind },

package/dist/src/commands/sensors/compatibility/discovery.js

@@ -190,6 +190,7 @@ function discoverProjectEvidence(cwd, pack, dependencies = {}) {
     }
     const configFiles = [...configCandidates].filter(file => safeFile(root, file)).sort();
     const scripts = Object.keys(stringMap(pkg?.scripts)).sort();
+    const packageJsonFields = Object.keys(pkg ?? {}).filter(field => /^[A-Za-z][A-Za-z0-9]*$/.test(field)).sort();
     const declaredToolRanges = { ...stringMap(pkg?.dependencies), ...stringMap(pkg?.devDependencies), ...stringMap(pkg?.peerDependencies) };
     const tools = new Set();
     if ('schemaVersion' in pack)
@@ -202,6 +203,6 @@ function discoverProjectEvidence(cwd, pack, dependencies = {}) {
     return {
         cwd: root, os: targetPlatform, runtimeVersions: { node: process.versions.node ?? null, ...(environment ? { python: environment.runtimeVersion } : {}) }, pythonEnvironmentRoot: environment?.rootParts[0] ?? null, declaredToolRanges, toolVersions,
         packageManager: declaredManager ?? (lockManagers.size === 1 ? [...lockManagers][0] : null), packageManagerConflict: lockManagers.size > 1,
-        scripts, configFiles, paths: [...new Set([...(safeFile(root, 'package.json') ? ['package.json'] : []), ...locks, ...configFiles])].sort(),
+        scripts, configFiles, packageJsonFields, paths: [...new Set([...(safeFile(root, 'package.json') ? ['package.json'] : []), ...locks, ...configFiles])].sort(),
     };
 }

package/dist/src/commands/sensors/compatibility/live.js

@@ -82,6 +82,7 @@ async function resolveParsedPackCompatibility(cwd, pack, options = {}) {
                 toolExecutable: variant.command.executable,
                 toolResolution: variant.command.resolution,
                 pythonEnvironmentRoot: variant.command.pythonEnvironmentRoot,
+                environment: variant.command.environment,
                 configFiles: evidence.configFiles,
                 scripts: evidence.scripts,
             })

package/dist/src/commands/sensors/compatibility/probe.js

@@ -16,7 +16,12 @@ function commandFor(kind, evidence) {
         return null;
     if (kind === 'config-present')
         return null;
-    const command = { executable, resolution, ...(resolution === 'python-environment' && evidence.pythonEnvironmentRoot ? { pythonEnvironmentRoot: evidence.pythonEnvironmentRoot } : {}) };
+    const command = {
+        executable,
+        resolution,
+        ...(resolution === 'python-environment' && evidence.pythonEnvironmentRoot ? { pythonEnvironmentRoot: evidence.pythonEnvironmentRoot } : {}),
+        ...(evidence.environment ? { environment: evidence.environment } : {}),
+    };
     if (kind === 'version')
         return { ...command, args: ['--version'] };
     if (kind === 'eslint-print-config')

package/dist/src/commands/sensors/compatibility/resolve.js

@@ -45,6 +45,17 @@ function toolFor(variant, evidence) {
 function runtimeFor(variant, evidence) {
     return evidence.runtimeVersions === undefined ? evidence.runtimeVersion : evidence.runtimeVersions[variant.requirements.runtime];
 }
+/** A variant may name alternative native configuration files that make it
+ * applicable. They are alternatives (for example `.eslintrc.*`), not a list
+ * that a project must contain in full. A variant without this requirement is
+ * configuration-agnostic. */
+function hasRequiredConfig(variant, evidence) {
+    const requiredFiles = variant.requirements.configFiles ?? [];
+    const requiredFields = variant.requirements.packageJsonFields ?? [];
+    return (requiredFiles.length === 0 && requiredFields.length === 0)
+        || requiredFiles.some(file => evidence.paths?.includes(file))
+        || requiredFields.some(field => evidence.packageJsonFields?.includes(field));
+}
 /** Pure precedence resolver. It consumes discovered evidence and neither probes nor executes commands. */
 function resolveSensorCompatibility(sensor, evidence, context) {
     if (!sensor || typeof sensor !== 'object' || !evidence || typeof evidence !== 'object')
@@ -66,7 +77,9 @@ function resolveSensorCompatibility(sensor, evidence, context) {
     const operational = v2.variants.filter(variant => validVersion(toolFor(variant, evidence)) && validVersion(runtimeFor(variant, evidence)));
     if (operational.length === 0)
         return result('unverifiable', 'invalid-or-missing-version-evidence', null, evidence);
-    const matches = operational.filter(variant => semver_1.default.satisfies(toolFor(variant, evidence), variant.requirements.toolRange) && semver_1.default.satisfies(runtimeFor(variant, evidence), variant.requirements.runtimeRange));
+    const matches = operational.filter(variant => semver_1.default.satisfies(toolFor(variant, evidence), variant.requirements.toolRange)
+        && semver_1.default.satisfies(runtimeFor(variant, evidence), variant.requirements.runtimeRange)
+        && hasRequiredConfig(variant, evidence));
     if (matches.length === 0)
         return result('incompatible', 'no-operational-variant', null, evidence);
     matches.sort((a, b) => b.priority - a.priority || specificity(b) - specificity(a) || a.id.localeCompare(b.id));

package/dist/tests/commands/sensors/compatibility/contract.test.js

@@ -150,9 +150,11 @@ describe('sensor pack v2 contract', () => {
         expect(() => (0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { applicability: { allFiles: [3] }, variants: [variant] } } }, 'pack')).toThrow('allFiles[0]');
         expect(() => (0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [{ ...variant, probe: { kind: 'version', extra: true } }] } } }, 'pack')).toThrow('unknown field');
     });
-    it('preserves configFiles and rejects incomplete public overlap input', () => {
-        const variant = { ...validPack().sensors.lint.variants[0], requirements: { ...validPack().sensors.lint.variants[0].requirements, configFiles: ['eslint.config.js'] } };
-        expect((0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [variant] } } }, 'pack')).toMatchObject({ kind: 'v2', pack: { sensors: { lint: { variants: [{ requirements: { configFiles: ['eslint.config.js'] } }] } } } });
+    it('preserves config selectors and validates package.json field names', () => {
+        const variant = { ...validPack().sensors.lint.variants[0], requirements: { ...validPack().sensors.lint.variants[0].requirements, configFiles: ['eslint.config.js'], packageJsonFields: ['eslintConfig'] } };
+        expect((0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [variant] } } }, 'pack')).toMatchObject({ kind: 'v2', pack: { sensors: { lint: { variants: [{ requirements: { configFiles: ['eslint.config.js'], packageJsonFields: ['eslintConfig'] } }] } } } });
+        const malformed = { ...variant, requirements: { ...variant.requirements, packageJsonFields: ['eslint-config'] } };
+        expect(() => (0, contract_1.parseSensorPack)({ ...validPack(), sensors: { lint: { ...validPack().sensors.lint, variants: [malformed] } } }, 'pack')).toThrow('packageJsonFields[0]');
         const complete = validPack().sensors.lint.variants[0];
         expect(() => (0, contract_1.assertNoEqualPriorityOverlap)([{ ...complete, id: '../bad' }])).toThrow('stable lowercase id');
         expect(() => (0, contract_1.assertNoEqualPriorityOverlap)([{ ...complete, command: undefined }])).toThrow('command');

package/dist/tests/commands/sensors/compatibility/discovery.test.js

@@ -11,7 +11,7 @@ describe('discoverProjectEvidence', () => {
     it('returns only local, relative project evidence and detects conflicting lockfiles', () => {
         const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-discovery-'));
         try {
-            fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' }, devDependencies: { eslint: '10.0.0' } }));
+            fs_1.default.writeFileSync(path_1.default.join(root, 'package.json'), JSON.stringify({ scripts: { lint: 'eslint .' }, eslintConfig: { env: { node: true } }, devDependencies: { eslint: '10.0.0' } }));
             fs_1.default.writeFileSync(path_1.default.join(root, 'package-lock.json'), '{}');
             fs_1.default.writeFileSync(path_1.default.join(root, 'pnpm-lock.yaml'), 'lockfileVersion: 9');
             fs_1.default.writeFileSync(path_1.default.join(root, 'eslint.config.js'), 'export default []');
@@ -24,6 +24,7 @@ describe('discoverProjectEvidence', () => {
             expect(evidence.toolVersions.eslint).toBe('10.4.1');
             expect(evidence.scripts).toContain('lint');
             expect(evidence.configFiles).toContain('eslint.config.js');
+            expect(evidence.packageJsonFields).toContain('eslintConfig');
             expect(evidence.paths.every((item) => !path_1.default.isAbsolute(item) && !item.includes('..'))).toBe(true);
         }
         finally {

package/dist/tests/commands/sensors/compatibility/probe.test.js

@@ -20,6 +20,15 @@ describe('runCompatibilityProbe', () => {
         await (0, probe_1.runCompatibilityProbe)({ kind: 'eslint-print-config' }, evidence, fakeExecutor);
         expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ executable: 'eslint', resolution: 'node-modules-bin' }), expect.any(Object));
     });
+    it('propagates the selected ESLint mode to its compatibility probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'eslint-print-config' }, {
+            ...evidence,
+            toolExecutable: 'eslint',
+            toolResolution: 'node-modules-bin',
+            environment: { ESLINT_USE_FLAT_CONFIG: 'true' },
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ environment: { ESLINT_USE_FLAT_CONFIG: 'true' } }), expect.any(Object));
+    });
     it('binds Semgrep validation to the contained Python environment', async () => {
         await (0, probe_1.runCompatibilityProbe)({ kind: 'semgrep-validate' }, evidence, fakeExecutor);
         expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ executable: 'semgrep', resolution: 'python-environment' }), expect.any(Object));

package/dist/tests/commands/sensors/compatibility/resolve.test.js

@@ -50,6 +50,32 @@ describe('resolveSensorCompatibility', () => {
         const resolved = (0, resolve_1.resolveSensorCompatibility)({ applicability: { allFiles: ['package.json'] }, variants }, evidence({ toolVersions: { eslint: '10.4.1', biome: null }, runtimeVersions: { node: '22.0.0' }, toolVersion: '8.0.0', runtimeVersion: '8.0.0' }), context);
         expect(resolved).toMatchObject({ state: 'certified', variantId: 'eslint', toolVersion: '10.4.1', runtimeVersion: '22.0.0' });
     });
+    it('selects the ESLint 8 flat variant from native config evidence before priority', () => {
+        const eslintrc = {
+            ...variant('eslint-8-eslintrc', 40, '>=8 <9', '=8.57.1'),
+            requirements: { ...variant('eslint-8-eslintrc').requirements, toolRange: '>=8 <9', configFiles: ['.eslintrc.json'] },
+        };
+        const flat = {
+            ...variant('eslint-8-flat', 30, '>=8 <9', '=8.57.1'),
+            requirements: { ...variant('eslint-8-flat').requirements, toolRange: '>=8 <9', configFiles: ['eslint.config.mjs'] },
+        };
+        const resolved = (0, resolve_1.resolveSensorCompatibility)({ applicability: { allFiles: ['package.json'] }, variants: [eslintrc, flat] }, evidence({ toolVersion: '8.57.1', paths: ['package.json', 'eslint.config.mjs'] }), context);
+        expect(resolved).toMatchObject({ state: 'certified', variantId: 'eslint-8-flat' });
+    });
+    it('selects the ESLint 8 eslintrc variant from package.json eslintConfig evidence', () => {
+        const eslintrc = {
+            ...variant('eslint-8-eslintrc', 40, '>=8 <9', '=8.57.1'),
+            requirements: { ...variant('eslint-8-eslintrc').requirements, toolRange: '>=8 <9', packageJsonFields: ['eslintConfig'] },
+        };
+        const flat = {
+            ...variant('eslint-8-flat', 30, '>=8 <9', '=8.57.1'),
+            requirements: { ...variant('eslint-8-flat').requirements, toolRange: '>=8 <9', configFiles: ['eslint.config.mjs'] },
+        };
+        const resolved = (0, resolve_1.resolveSensorCompatibility)({ applicability: { allFiles: ['package.json'] }, variants: [eslintrc, flat] }, evidence({ toolVersion: '8.57.1', paths: ['package.json'], packageJsonFields: ['eslintConfig'] }), context);
+        expect(resolved).toMatchObject({ state: 'certified', variantId: 'eslint-8-eslintrc' });
+        expect((0, resolve_1.resolveSensorCompatibility)({ applicability: { allFiles: ['package.json'] }, variants: [eslintrc, flat] }, evidence({ toolVersion: '8.57.1', paths: ['package.json'], packageJsonFields: [] }), context))
+            .toMatchObject({ state: 'incompatible', variantId: null });
+    });
     it('does not reuse scalar evidence for a missing key in a version map', () => {
         const biome = { ...variant('biome'), requirements: { ...variant('biome').requirements, tool: 'biome', runtime: 'bun' } };
         expect((0, resolve_1.resolveSensorCompatibility)({ applicability: { allFiles: ['package.json'] }, variants: [biome] }, evidence({ toolVersions: { biome: null }, runtimeVersions: { bun: null }, toolVersion: '10.4.1', runtimeVersion: '22.0.0' }), context))

package/dist/tests/commands/sensors/init.test.js

@@ -305,6 +305,7 @@ describe('initSensors', () => {
             const automatic = await (0, init_1.initSensors)({ cwd: tmpDir, registryRoot: v2Registry, configure: false });
             expect(automatic.manifest).toMatchObject({ schemaVersion: 2, pack: 'generic', sensors: {} });
             expect(automatic.manifest.packSelection).toBeUndefined();
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, 'generic.config'), 'fixture\n');
             const explicit = await (0, init_1.initSensors)({ cwd: tmpDir, registryRoot: v2Registry, pack: 'generic' });
             const written = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), 'utf8'));
             expect(explicit.manifest).toMatchObject({ schemaVersion: 2, pack: 'generic', packSelection: 'explicit', sensors: { security: { variantId: 'eslint-10' } } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "8.1.1",
+  "version": "8.1.2",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"