agentic-workflow-manager 8.2.0 → 8.2.1

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

@@ -85,6 +85,7 @@ async function resolveParsedPackCompatibility(cwd, pack, options = {}) {
                 environment: variant.command.environment,
                 configFiles: evidence.configFiles,
                 scripts: evidence.scripts,
+                variantArgs: variant.command.args,
             })
             : null;
         sensors[name] = (0, resolve_1.resolveProjectCompatibility)({ ...executionPack, sensors: { [name]: sensor } }, { ...resolutionEvidence, probe: probe ?? undefined }).sensors[name];

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

@@ -24,11 +24,23 @@ function commandFor(kind, evidence) {
     };
     if (kind === 'version')
         return { ...command, args: ['--version'] };
+    // A pack asset is never named the tool's default config filename (e.g.
+    // `eslint.config.awm.mjs`, not `eslint.config.js`), so the real command always
+    // pins it via an explicit `--config <file>`. Mirroring that same pair here — rather
+    // than probing with a bare invocation — is what lets the probe find the config the
+    // real run will actually use, for whatever name or tool version is in play.
     if (kind === 'eslint-print-config')
-        return { ...command, args: ['--print-config', evidence.configFiles?.[0] ?? 'package.json'] };
+        return { ...command, args: [...configFlag(evidence.variantArgs), '--print-config', evidence.configFiles?.[0] ?? 'package.json'] };
     if (kind === 'typescript-show-config')
-        return { ...command, args: ['--showConfig'] };
-    return { ...command, args: ['--validate'] };
+        return { ...command, args: [...configFlag(evidence.variantArgs), '--showConfig'] };
+    return { ...command, args: [...configFlag(evidence.variantArgs), '--validate'] };
+}
+/** The `--config <file>` pair from a variant's real command args, if it declares one. */
+function configFlag(variantArgs) {
+    if (!variantArgs)
+        return [];
+    const i = variantArgs.indexOf('--config');
+    return i !== -1 && variantArgs[i + 1] !== undefined ? ['--config', variantArgs[i + 1]] : [];
 }
 /** Executes only the closed probe enum. Raw output is intentionally discarded. */
 async function runCompatibilityProbe(probe, evidence, executor = exec_1.runStructuredCommand) {

package/dist/src/commands/sensors/status.js

@@ -145,10 +145,14 @@ async function computeSensorStatus(cwd = process.cwd()) {
         const raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
         const parsed = (0, manifest_1.parseSensorManifest)(raw, manifestPath);
         if (parsed.kind === 'v2') {
+            // Monorepo support (mirrors run.ts/init.ts): detection and structured-command
+            // asset resolution both need to see the real package, not the (possibly
+            // unrelated) directory the manifest lives in.
+            const projectCwd = parsed.pack.packageRoot ? path_1.default.resolve(cwd, parsed.pack.packageRoot) : cwd;
             const checks = {};
             let compatibility;
             try {
-                compatibility = resolveStaticV2Compatibility(cwd, parsed.pack);
+                compatibility = resolveStaticV2Compatibility(projectCwd, parsed.pack);
             }
             catch (error) {
                 const detail = error instanceof Error ? error.message : 'live compatibility unavailable';
@@ -163,7 +167,7 @@ async function computeSensorStatus(cwd = process.cwd()) {
                     continue;
                 }
                 checks[name] = staticCompatibilityCheck(sensor, compatibility[name])
-                    ?? checkStructuredCommand(sensor.command, cwd, sensor.assets);
+                    ?? checkStructuredCommand(sensor.command, projectCwd, sensor.assets);
             }
             return { overall: Object.keys(checks).length > 0 && Object.values(checks).every(check => check.ok) ? 'READY' : 'DEGRADED', pack: parsed.pack.pack, checks };
         }

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

@@ -53,4 +53,31 @@ describe('runCompatibilityProbe', () => {
         await (0, probe_1.runCompatibilityProbe)({ kind: 'version' }, { ...evidence, toolExecutable, toolResolution: 'python-environment' }, fakeExecutor);
         expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ executable: toolExecutable, resolution: 'python-environment', args: ['--version'] }), expect.any(Object));
     });
+    // A pack asset is never named the tool's own default (e.g. `eslint.config.awm.mjs`,
+    // not `eslint.config.js`) so the real command always pins it via `--config`. A probe
+    // that omits the same flag never finds a config to load and always reports
+    // not-matched — a false negative on every AWM-configured project. The probe must
+    // mirror the variant's own `--config` argument, not guess a bare invocation.
+    it('carries the variant\'s --config argument into an eslint-print-config probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'eslint-print-config' }, {
+            ...evidence, variantArgs: ['.', '--config', 'eslint.config.awm.mjs', '--cache', '--format', 'json'],
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--config', 'eslint.config.awm.mjs', '--print-config', 'eslint.config.js'] }), expect.any(Object));
+    });
+    it('carries the variant\'s --config argument into a typescript-show-config probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'typescript-show-config' }, {
+            ...evidence, variantArgs: ['--config', 'tsconfig.awm.json', '--noEmit'],
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--config', 'tsconfig.awm.json', '--showConfig'] }), expect.any(Object));
+    });
+    it('carries the variant\'s --config argument into a semgrep-validate probe', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'semgrep-validate' }, {
+            ...evidence, variantArgs: ['--config', '.semgrep.awm.yml', '--json', '.'],
+        }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--config', '.semgrep.awm.yml', '--validate'] }), expect.any(Object));
+    });
+    it('omits --config from the probe when the variant command declares none', async () => {
+        await (0, probe_1.runCompatibilityProbe)({ kind: 'eslint-print-config' }, { ...evidence, variantArgs: ['.', '--cache'] }, fakeExecutor);
+        expect(fakeExecutor).toHaveBeenCalledWith(expect.objectContaining({ args: ['--print-config', 'eslint.config.js'] }), expect.any(Object));
+    });
 });

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

@@ -182,6 +182,64 @@ describe('computeSensorStatus', () => {
         expect(result.pack).toBe('python');
         expect(result.checks).toEqual({});
     });
+    it('resolves v2 compatibility and structured-command assets against packageRoot in a monorepo', async () => {
+        // Monorepo support (mirrors run.ts/init.ts): the manifest lives at the repo
+        // root, but package.json/node_modules/the config asset all live under the
+        // declared packageRoot subdirectory. Without threading packageRoot through,
+        // detection finds no package.json at the manifest's own directory and every
+        // sensor reads back "not-applicable" — a false compatibility drift on every
+        // check, even immediately after a correct `awm sensors init --package-root`.
+        const previousHome = process.env.AWM_HOME;
+        const home = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-status-home-'));
+        try {
+            process.env.AWM_HOME = home;
+            const registry = path_1.default.join(home, 'registries', 'baseline');
+            fs_1.default.mkdirSync(path_1.default.join(registry, 'sensor-packs', 'js-ts'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(home, 'registries.json'), JSON.stringify([{ name: 'baseline', remote: 'https://example.test/baseline.git' }]));
+            fs_1.default.writeFileSync(path_1.default.join(registry, 'sensor-packs', 'js-ts', 'pack.json'), JSON.stringify({
+                schemaVersion: 2, name: 'js-ts', description: 'test', detects: ['package.json'],
+                coverage: { schemaVersion: 1, classes: { lint: { description: 'lint', detectors: [{ sensor: 'lint' }], remedy: { summary: 'fix lint', command: 'awm sensors init --pack js-ts' } } } },
+                sensors: { lint: {
+                        applicability: { allFiles: ['package.json'] },
+                        variants: [{
+                                id: 'eslint-10', priority: 10, certifiedRange: '>=10.0.0 <11.0.0',
+                                requirements: { tool: 'eslint', toolRange: '>=10.0.0 <11.0.0', runtime: 'node', runtimeRange: '>=0.0.0' },
+                                assets: ['eslint.config.awm.mjs'], formatter: 'eslint-llm', probe: { kind: 'package-script-present' },
+                                command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--config', 'eslint.config.awm.mjs'] },
+                            }],
+                    } },
+            }));
+            const packageDir = path_1.default.join(tmpDir, 'cli');
+            fs_1.default.mkdirSync(packageDir, { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'package.json'), JSON.stringify({ devDependencies: { eslint: '^10.0.0' }, scripts: { lint: 'eslint .' } }));
+            fs_1.default.mkdirSync(path_1.default.join(packageDir, 'node_modules', 'eslint'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'node_modules', 'eslint', 'package.json'), JSON.stringify({ version: '10.4.1' }));
+            fs_1.default.mkdirSync(path_1.default.join(packageDir, 'node_modules', '.bin'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'node_modules', '.bin', 'eslint'), '');
+            fs_1.default.writeFileSync(path_1.default.join(packageDir, 'eslint.config.awm.mjs'), 'export default []');
+            fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
+            fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({
+                schemaVersion: 2, pack: 'js-ts', packageRoot: 'cli', registryRoot: registry,
+                sensors: { lint: {
+                        enabled: true, variantId: 'eslint-10', command: { executable: 'eslint', resolution: 'node-modules-bin', args: ['.', '--config', 'eslint.config.awm.mjs'] },
+                        assets: ['eslint.config.awm.mjs'],
+                        initializedCompatibility: { state: 'certified', reason: 'range-and-probe', variantId: 'eslint-10', toolVersion: '10.4.1', runtimeVersion: process.versions.node, certifiedRange: '>=10.0.0 <11.0.0', evidence: [] },
+                    } },
+            }));
+            const result = await (0, status_1.computeSensorStatus)(tmpDir);
+            expect(result.checks.lint).toMatchObject({ ok: true });
+            expect(result.overall).toBe('READY');
+            expect(runCommand).not.toHaveBeenCalled();
+            expect(runStructuredCommand).not.toHaveBeenCalled();
+        }
+        finally {
+            if (previousHome === undefined)
+                delete process.env.AWM_HOME;
+            else
+                process.env.AWM_HOME = previousHome;
+            fs_1.default.rmSync(home, { recursive: true, force: true });
+        }
+    });
     it('marks disabled sensors as ok', async () => {
         fs_1.default.mkdirSync(path_1.default.join(tmpDir, '.awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(tmpDir, '.awm', 'sensors.json'), JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-workflow-manager",
-  "version": "8.2.0",
+  "version": "8.2.1",
   "main": "dist/src/index.js",
   "bin": {
     "awm": "./dist/src/index.js"
@@ -56,7 +56,7 @@
     "@types/node": "^25.3.0",
     "@types/semver": "^7.7.1",
     "dependency-cruiser": "^17.4.3",
-    "eslint": "^10.4.1",
+    "eslint": "10.8.1",
     "jest": "^30.2.0",
     "js-yaml": "4.1.0",
     "ts-jest": "^29.4.6",