@bonesofspring/ai-rules 0.2.21 → 0.2.23

package/scripts/test-probe-mavis-capabilities.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const probeScript = path.join(scriptDirectory, 'probe-mavis-capabilities.mjs');
+const fixtureDirectory = path.join(scriptDirectory, 'fixtures', 'mavis-probe');
+const fakeMcodeSource = path.join(fixtureDirectory, 'fake-mcode.mjs');
+
+assert.equal(fs.existsSync(probeScript), true, 'probe script must exist');
+
+function installFakeMcode(tempRoot) {
+  const fakeMcode = path.join(tempRoot, 'mcode');
+  fs.copyFileSync(fakeMcodeSource, fakeMcode);
+  fs.chmodSync(fakeMcode, 0o755);
+  return fakeMcode;
+}
+
+function runProbe({ mcode, workdir, home, mode }) {
+  try {
+    const stdout = execFileSync(
+      process.execPath,
+      [probeScript, '--mcode', mcode, '--workdir', workdir],
+      {
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          HOME: home,
+          FAKE_MCODE_MODE: mode ?? 'supported',
+        },
+      },
+    );
+    return { exitCode: 0, evidence: JSON.parse(stdout) };
+  } catch (error) {
+    return {
+      exitCode: error.status ?? 1,
+      evidence: JSON.parse(error.stdout),
+    };
+  }
+}
+
+function assertCapabilityShape(capability) {
+  assert.match(capability.status, /^(confirmed|partial|unknown|no-equivalent)$/);
+  assert.ok(Object.hasOwn(capability, 'command'));
+  assert.ok(Object.hasOwn(capability, 'exitCode'));
+  assert.ok(Object.hasOwn(capability, 'executed'));
+  assert.equal(typeof capability.observation, 'string');
+}
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-probe-test-'));
+
+try {
+  const home = path.join(tempRoot, 'home');
+  fs.mkdirSync(home);
+  const fakeMcode = installFakeMcode(tempRoot);
+
+  const freshWorkdir = path.join(tempRoot, 'fresh-workdir');
+  const fresh = runProbe({ mcode: fakeMcode, workdir: freshWorkdir, home });
+  assert.equal(fresh.exitCode, 0);
+  assert.equal(fresh.evidence.schemaVersion, 1);
+  assert.equal(fresh.evidence.probeStatus, 'completed');
+  assert.deepEqual(fresh.evidence.cli, {
+    executable: '<MCODE>',
+    version: 'mcode 9.8.7',
+  });
+  assert.ok(fresh.evidence.os.platform);
+  assert.ok(fresh.evidence.os.release);
+  assert.ok(fresh.evidence.os.arch);
+  assert.equal(fresh.evidence.workdir, '<WORKDIR>');
+
+  const requiredCapabilities = [
+    'cliVersion',
+    'cliHelp',
+    'freshInit',
+    'rootAgents',
+    'referencedRule',
+    'referencedSkill',
+    'explicitAgentFile',
+    'structuredOutput',
+    'nativeProjectRules',
+    'nativeWorkspaceSkills',
+    'nativeWorkspaceAgents',
+    'projectMcp',
+    'projectHooks',
+    'slashCommands',
+    'pluginSkillMcp',
+    'nativeTeam',
+  ];
+  assert.deepEqual(Object.keys(fresh.evidence.capabilities), requiredCapabilities);
+  for (const capability of Object.values(fresh.evidence.capabilities)) {
+    assertCapabilityShape(capability);
+  }
+
+  assert.equal(fresh.evidence.capabilities.rootAgents.status, 'confirmed');
+  assert.equal(fresh.evidence.capabilities.referencedRule.status, 'confirmed');
+  assert.equal(fresh.evidence.capabilities.referencedSkill.status, 'confirmed');
+  assert.equal(fresh.evidence.capabilities.explicitAgentFile.status, 'confirmed');
+  assert.equal(fresh.evidence.capabilities.structuredOutput.status, 'confirmed');
+  assert.equal(fresh.evidence.capabilities.nativeProjectRules.status, 'unknown');
+  assert.equal(fresh.evidence.capabilities.nativeWorkspaceSkills.status, 'unknown');
+  assert.equal(fresh.evidence.capabilities.nativeWorkspaceAgents.status, 'unknown');
+  assert.equal(fresh.evidence.capabilities.nativeProjectRules.executed, true);
+  assert.equal(fresh.evidence.capabilities.nativeWorkspaceSkills.executed, true);
+  assert.equal(fresh.evidence.capabilities.nativeWorkspaceAgents.executed, true);
+  assert.deepEqual(
+    fresh.evidence.capabilities.explicitAgentFile.command.slice(0, 3),
+    ['<MCODE>', 'exec', '--cwd'],
+  );
+  assert.ok(fresh.evidence.capabilities.explicitAgentFile.command.includes('--file'));
+  assert.ok(fresh.evidence.capabilities.structuredOutput.command.includes('--output-format'));
+  assert.ok(fresh.evidence.capabilities.structuredOutput.command.includes('--permission'));
+  assert.ok(fresh.evidence.capabilities.structuredOutput.command.includes('off'));
+  assert.ok(fresh.evidence.capabilities.structuredOutput.command.includes('--timeout'));
+  assert.deepEqual(fresh.evidence.authSeed, { seeded: false, entries: [] });
+  assert.equal(fresh.evidence.capabilities.projectMcp.status, 'unknown');
+  assert.equal(fresh.evidence.capabilities.projectMcp.exitCode, null);
+  assert.equal(fresh.evidence.capabilities.projectMcp.executed, false);
+  assert.match(fresh.evidence.capabilities.projectMcp.observation, /not executed/i);
+  assert.equal(fresh.evidence.capabilities.projectHooks.status, 'unknown');
+  assert.equal(fresh.evidence.capabilities.slashCommands.status, 'unknown');
+  assert.equal(fresh.evidence.capabilities.pluginSkillMcp.status, 'confirmed');
+  assert.equal(fresh.evidence.capabilities.pluginSkillMcp.executed, false);
+  assert.equal(fresh.evidence.capabilities.nativeTeam.status, 'partial');
+  assert.equal(fresh.evidence.capabilities.nativeTeam.executed, false);
+
+  assert.equal(fs.existsSync(path.join(freshWorkdir, 'AGENTS.md')), true);
+  assert.equal(fs.existsSync(path.join(freshWorkdir, 'rules', 'probe.md')), true);
+  assert.equal(fs.existsSync(path.join(freshWorkdir, 'agents', 'probe-agent.md')), true);
+  assert.equal(fs.existsSync(path.join(freshWorkdir, 'skills', 'probe', 'SKILL.md')), true);
+  assert.equal(fs.existsSync(path.join(freshWorkdir, 'output.schema.json')), true);
+  assert.equal(fs.existsSync(path.join(home, '.minimax')), false);
+
+  const serialized = JSON.stringify(fresh.evidence);
+  assert.doesNotMatch(serialized, /fixture-secret|fake-secret/);
+  assert.doesNotMatch(serialized, /\/Users\/tester/);
+  assert.doesNotMatch(serialized, new RegExp(tempRoot.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+  assert.doesNotMatch(serialized, /mavis-probe-home-/);
+  assert.doesNotMatch(serialized, /<PROBE_HOME>/);
+  assert.match(serialized, /<REDACTED>|<HOME>/);
+
+  const emptyWorkdir = path.join(tempRoot, 'empty-workdir');
+  fs.mkdirSync(emptyWorkdir);
+  const empty = runProbe({ mcode: fakeMcode, workdir: emptyWorkdir, home });
+  assert.equal(empty.exitCode, 0);
+  assert.deepEqual(empty.evidence, fresh.evidence);
+  assert.equal(fs.existsSync(path.join(home, '.minimax')), false);
+
+  const nonemptyWorkdir = path.join(tempRoot, 'nonempty-workdir');
+  fs.mkdirSync(nonemptyWorkdir);
+  fs.writeFileSync(path.join(nonemptyWorkdir, 'keep.txt'), 'preserve-me');
+  const nonempty = runProbe({ mcode: fakeMcode, workdir: nonemptyWorkdir, home });
+  assert.equal(nonempty.exitCode, 2);
+  assert.equal(nonempty.evidence.probeStatus, 'blocked');
+  assert.equal(nonempty.evidence.capabilities.cliVersion.executed, false);
+  assert.match(nonempty.evidence.capabilities.freshInit.observation, /empty/i);
+  assert.equal(fs.readFileSync(path.join(nonemptyWorkdir, 'keep.txt'), 'utf8'), 'preserve-me');
+  assert.equal(fs.existsSync(path.join(home, '.minimax')), false);
+
+  const seededHome = path.join(tempRoot, 'seeded-home');
+  fs.mkdirSync(path.join(seededHome, '.minimax', 'cli-auth'), { recursive: true });
+  fs.writeFileSync(path.join(seededHome, '.minimax', 'cli-auth', 'session'), 'seed-only');
+  fs.writeFileSync(path.join(seededHome, '.minimax', 'config.yaml'), 'region: test\n');
+  const seeded = runProbe({
+    mcode: fakeMcode,
+    workdir: path.join(tempRoot, 'seeded-workdir'),
+    home: seededHome,
+  });
+  assert.equal(seeded.exitCode, 0);
+  assert.equal(seeded.evidence.authSeed.seeded, true);
+  assert.deepEqual(seeded.evidence.authSeed.entries, ['cli-auth', 'config.yaml']);
+  assert.equal(fs.existsSync(path.join(seededHome, '.minimax', 'probe-touch')), false);
+
+  const missing = runProbe({
+    mcode: path.join(tempRoot, 'missing-mcode'),
+    workdir: path.join(tempRoot, 'missing-executable-workdir'),
+    home,
+  });
+  assert.equal(missing.exitCode, 2);
+  assert.equal(missing.evidence.probeStatus, 'blocked');
+  assert.equal(missing.evidence.cli.version, null);
+  assert.equal(missing.evidence.capabilities.cliVersion.status, 'unknown');
+  assert.match(missing.evidence.capabilities.cliVersion.observation, /not found/i);
+  assert.equal(fs.existsSync(path.join(home, '.minimax')), false);
+
+  const unsupported = runProbe({
+    mcode: fakeMcode,
+    workdir: path.join(tempRoot, 'unsupported-workdir'),
+    home,
+    mode: 'unsupported',
+  });
+  assert.equal(unsupported.exitCode, 2);
+  assert.equal(unsupported.evidence.probeStatus, 'blocked');
+  assert.equal(unsupported.evidence.cli.version, null);
+  assert.equal(unsupported.evidence.capabilities.cliVersion.exitCode, 64);
+  assert.match(unsupported.evidence.capabilities.cliVersion.observation, /unsupported/i);
+  assert.equal(fs.existsSync(path.join(home, '.minimax')), false);
+
+  console.log('test-probe-mavis-capabilities: ok');
+} finally {
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+}

package/scripts/test-task-router-intents-fixtures.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// Fixtures for check-task-router-intents.sh.
+//
+// Scenario: rename the frontmatter `name:` of an existing shipped agent
+// (cursor/next/agents/build-verifier.md → `build-verifier-renamed`) and
+// confirm the check FAILS. Then revert and confirm it PASSES.
+//
+// Why a separate fixture file: the check is a shell + Python script under
+// `scripts/`, not an in-process module, so we exercise it end-to-end via
+// `execFileSync` against a temp copy of `agents/` (mirroring the pattern in
+// `test-chain-team-phases-coverage.mjs` and `test-cli-mcp-merge.mjs`).
+//
+// The fixture operates on a *copy* of `presets/cursor/next/agents/` so the
+// real preset tree is never mutated, even on assertion failure.
+
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageDirectory = path.resolve(scriptDirectory, '..');
+const checkScript = path.join(scriptDirectory, 'check-task-router-intents.sh');
+
+function runCheck(env) {
+  try {
+    return {
+      exitCode: 0,
+      stdout: execFileSync('bash', [checkScript], { env, encoding: 'utf8' }),
+    };
+  } catch (error) {
+    return {
+      exitCode: error.status ?? 1,
+      stdout: `${error.stdout ?? ''}${error.stderr ?? ''}`,
+    };
+  }
+}
+
+function copyAgentsDir(sourceAgentsDir) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'task-router-intents-'));
+  // Mirror full preset tree so the Python script's iteration works.
+  const sourcePresetsDir = path.join(packageDirectory, 'presets');
+  const targetPresetsDir = path.join(tempRoot, 'packages', 'ai-rules', 'presets');
+  fs.mkdirSync(targetPresetsDir, { recursive: true });
+  copyTree(sourcePresetsDir, targetPresetsDir);
+  return tempRoot;
+}
+
+function copyTree(source, destination) {
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const src = path.join(source, entry.name);
+    const dest = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(dest, { recursive: true });
+      copyTree(src, dest);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function setEnvPresetRoot(tempRoot) {
+  return { ...process.env, AI_RULES_PRESETS_ROOT: path.join(tempRoot, 'packages', 'ai-rules', 'presets') };
+}
+
+// Test 1 — rename frontmatter `name:` and assert the script returns non-zero.
+{
+  const tempRoot = copyAgentsDir(path.join(packageDirectory, 'presets', 'cursor', 'next', 'agents'));
+  try {
+    const agentFile = path.join(tempRoot, 'packages', 'ai-rules', 'presets', 'cursor', 'next', 'agents', 'build-verifier.md');
+    const original = fs.readFileSync(agentFile, 'utf8');
+    const renamed = original.replace(/^name:\s*build-verifier\s*$/m, 'name: build-verifier-renamed');
+    assert.notStrictEqual(renamed, original, 'rename pattern must match exactly one line');
+    fs.writeFileSync(agentFile, renamed);
+
+    const result = runCheck(setEnvPresetRoot(tempRoot));
+    assert.notStrictEqual(
+      result.exitCode,
+      0,
+      `expected FAIL when name frontmatter does not match stem; got exit=${result.exitCode}\n${result.stdout}`,
+    );
+    assert.match(
+      result.stdout,
+      /task-router vs agents drift/,
+      'expected drift failure message in output',
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+// Test 2 — revert and assert the script returns zero.
+{
+  const tempRoot = copyAgentsDir(path.join(packageDirectory, 'presets', 'cursor', 'next', 'agents'));
+  try {
+    const result = runCheck(setEnvPresetRoot(tempRoot));
+    assert.strictEqual(
+      result.exitCode,
+      0,
+      `expected PASS on unmodified copy; got exit=${result.exitCode}\n${result.stdout}`,
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+console.log('OK: check-task-router-intents.sh fixture tests passed');