@bonesofspring/ai-rules 0.2.22 → 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 });
+}