@bonesofspring/ai-rules 0.2.22 → 0.2.24

package/scripts/lib/cli-golden.mjs

@@ -0,0 +1,50 @@
+import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function sha256File(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+export function walkRelativeFiles(root) {
+  const files = [];
+  const visit = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.name === '.DS_Store') {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        visit(full);
+      } else if (entry.isFile()) {
+        files.push(path.relative(root, full).split(path.sep).join('/'));
+      }
+    }
+  };
+  visit(root);
+  return files.sort();
+}
+
+export function snapshotInstall(root) {
+  const files = {};
+  for (const rel of walkRelativeFiles(root)) {
+    files[rel] = sha256File(path.join(root, rel));
+  }
+  return files;
+}
+
+export function runInit(cli, cwd, tool, preset) {
+  return execFileSync(process.execPath, [cli, 'init', tool, '--preset', preset, '--cwd', cwd], {
+    encoding: 'utf8',
+  });
+}
+
+export function goldenDocument({ tool, preset, files }) {
+  return {
+    schemaVersion: 1,
+    tool,
+    preset,
+    files,
+  };
+}

package/scripts/lib/discover-hooks.mjs

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function loadReleasedMavisStacks(presetsRoot) {
+  const contractPath = path.join(presetsRoot, 'mavis', 'platform-contract.json');
+  if (!fs.existsSync(contractPath)) {
+    return [];
+  }
+  const contract = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+  return Array.isArray(contract.releasedStacks) ? contract.releasedStacks : [];
+}
+
+export function loadReleasedOpencodeStacks(presetsRoot) {
+  const contractPath = path.join(presetsRoot, 'opencode', 'platform-contract.json');
+  if (!fs.existsSync(contractPath)) {
+    return [];
+  }
+  const contract = JSON.parse(fs.readFileSync(contractPath, 'utf8'));
+  return Array.isArray(contract.releasedStacks) ? contract.releasedStacks : [];
+}
+
+export function discoverChainHooks(presetsRoot) {
+  const hooks = [];
+  for (const platform of ['cursor', 'claude']) {
+    const platformDir = path.join(presetsRoot, platform);
+    if (!fs.existsSync(platformDir)) {
+      continue;
+    }
+    for (const stack of fs.readdirSync(platformDir)) {
+      const hook = path.join(platformDir, stack, 'hooks', 'chain-team-phases.sh');
+      if (fs.existsSync(hook)) {
+        hooks.push(hook);
+      }
+    }
+  }
+  for (const stack of loadReleasedMavisStacks(presetsRoot)) {
+    const hook = path.join(presetsRoot, 'mavis', stack, 'hooks', 'chain-team-phases.sh');
+    if (fs.existsSync(hook)) {
+      hooks.push(hook);
+    }
+  }
+  for (const stack of loadReleasedOpencodeStacks(presetsRoot)) {
+    const hook = path.join(presetsRoot, 'opencode', stack, 'hooks', 'chain-team-phases.sh');
+    if (fs.existsSync(hook)) {
+      hooks.push(hook);
+    }
+  }
+  return hooks;
+}
+
+export function platformFromHook(hookPath) {
+  const parts = hookPath.split(path.sep);
+  const presetsIndex = parts.lastIndexOf('presets');
+  if (presetsIndex >= 0 && parts[presetsIndex + 1]) {
+    return parts[presetsIndex + 1];
+  }
+  if (hookPath.includes(`${path.sep}mavis${path.sep}`)) {
+    return 'mavis';
+  }
+  if (hookPath.includes(`${path.sep}opencode${path.sep}`)) {
+    return 'opencode';
+  }
+  if (hookPath.includes(`${path.sep}cursor${path.sep}`)) {
+    return 'cursor';
+  }
+  return 'claude';
+}
+
+export function expectedLegacyHookCount(presetsRoot) {
+  let count = 0;
+  for (const platform of ['cursor', 'claude']) {
+    const platformDir = path.join(presetsRoot, platform);
+    if (!fs.existsSync(platformDir)) {
+      continue;
+    }
+    for (const stack of fs.readdirSync(platformDir)) {
+      const hook = path.join(platformDir, stack, 'hooks', 'chain-team-phases.sh');
+      if (fs.existsSync(hook)) {
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+
+export function expectedHookCount(presetsRoot) {
+  const mavisCount = loadReleasedMavisStacks(presetsRoot).filter((stack) =>
+    fs.existsSync(path.join(presetsRoot, 'mavis', stack, 'hooks', 'chain-team-phases.sh')),
+  ).length;
+  const opencodeCount = loadReleasedOpencodeStacks(presetsRoot).filter((stack) =>
+    fs.existsSync(path.join(presetsRoot, 'opencode', stack, 'hooks', 'chain-team-phases.sh')),
+  ).length;
+  return expectedLegacyHookCount(presetsRoot) + mavisCount + opencodeCount;
+}

package/scripts/probe-mavis-capabilities.mjs

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+import { spawnSync } 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 fixtureDirectory = path.join(scriptDirectory, 'fixtures', 'mavis-probe');
+
+const LIBRARY_INPUTS = [
+  path.join('rules', 'probe.md'),
+  path.join('agents', 'probe-agent.md'),
+  path.join('skills', 'probe', 'SKILL.md'),
+  'output.schema.json',
+];
+
+function parseArguments(argv) {
+  const values = new Map();
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!['--mcode', '--workdir'].includes(flag) || !value) {
+      throw new Error('Usage: probe-mavis-capabilities.mjs --mcode <path> --workdir <path>');
+    }
+    values.set(flag, value);
+  }
+  if (!values.has('--mcode') || !values.has('--workdir')) {
+    throw new Error('Both --mcode and --workdir are required');
+  }
+  return {
+    mcode: path.resolve(values.get('--mcode')),
+    workdir: path.resolve(values.get('--workdir')),
+  };
+}
+
+function createRedactor({ mcode, workdir, isolatedHome }) {
+  const replacements = [
+    [mcode, '<MCODE>'],
+    [workdir, '<WORKDIR>'],
+    [isolatedHome, '<PROBE_HOME>'],
+    [os.homedir(), '<HOME>'],
+  ]
+    .filter(([source]) => Boolean(source))
+    .sort(([left], [right]) => right.length - left.length);
+
+  return (value) => {
+    let redacted = String(value ?? '');
+    for (const [source, target] of replacements) {
+      redacted = redacted.split(source).join(target);
+    }
+    return redacted
+      .replace(/\/(?:Users|home)\/[^/\s"']+\/\.minimax/g, '<HOME>/.minimax')
+      .replace(/(Bearer\s+)[^\s"',]+/gi, '$1<REDACTED>')
+      .replace(
+        /((?:api[_-]?key|token|secret|password)\s*[=:]\s*)[^\s"',]+/gi,
+        '$1<REDACTED>',
+      )
+      .trim();
+  };
+}
+
+function commandForEvidence(args, redact) {
+  return args.map((argument) => redact(argument));
+}
+
+function capability({ status, command = null, exitCode = null, observation, executed = false }) {
+  return { status, command, exitCode, observation, executed };
+}
+
+function loadInlineOutputSchema() {
+  return JSON.stringify(JSON.parse(fs.readFileSync(path.join(fixtureDirectory, 'output.schema.json'), 'utf8')));
+}
+
+function createCapabilities(redact, mcode, workdir) {
+  const documentedMcpCommand = commandForEvidence([mcode, 'mcp', 'list', '--human'], redact);
+  const execSafety = ['--permission', 'off', '--timeout', '3m', '--max-steps', '16'];
+  const model = process.env.MAVIS_PROBE_MODEL;
+  if (model) execSafety.push('--model', model);
+  const outputSchema = loadInlineOutputSchema();
+  const structuredCommand = [
+    mcode,
+    'exec',
+    '--cwd',
+    workdir,
+    '--output-format',
+    'json',
+    ...execSafety,
+    'Return the requested capability sentinels.',
+  ];
+  if (process.env.MAVIS_PROBE_USE_SCHEMA === '1') {
+    structuredCommand.splice(structuredCommand.indexOf('json') + 1, 0, '--output-schema', outputSchema);
+  }
+  const roleCommand = [
+    mcode,
+    'exec',
+    '--cwd',
+    workdir,
+    '--file',
+    'agents/probe-agent.md',
+    '--output-format',
+    'json',
+    ...execSafety,
+    'Return the requested role sentinel.',
+  ];
+  if (process.env.MAVIS_PROBE_USE_SCHEMA === '1') {
+    roleCommand.splice(roleCommand.indexOf('json') + 1, 0, '--output-schema', outputSchema);
+  }
+  const structuredEvidence = commandForEvidence(structuredCommand, redact);
+
+  return {
+    cliVersion: capability({
+      status: 'unknown',
+      command: commandForEvidence([mcode, '--version'], redact),
+      observation: 'Not executed.',
+    }),
+    cliHelp: capability({
+      status: 'unknown',
+      command: commandForEvidence([mcode, '--help'], redact),
+      observation: 'Not executed.',
+    }),
+    freshInit: capability({
+      status: 'unknown',
+      command: commandForEvidence([mcode, 'init', workdir], redact),
+      observation: 'Not executed.',
+    }),
+    rootAgents: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    referencedRule: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    referencedSkill: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    explicitAgentFile: capability({
+      status: 'unknown',
+      command: commandForEvidence(roleCommand, redact),
+      observation: 'Not executed.',
+    }),
+    structuredOutput: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    nativeProjectRules: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    nativeWorkspaceSkills: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    nativeWorkspaceAgents: capability({
+      status: 'unknown',
+      command: structuredEvidence,
+      observation: 'Not executed.',
+    }),
+    projectMcp: capability({
+      status: 'unknown',
+      command: documentedMcpCommand,
+      observation:
+        'Documented inspection command only; not executed to avoid reading or changing user-global MCP state.',
+    }),
+    projectHooks: capability({
+      status: 'unknown',
+      command: null,
+      observation:
+        'No documented project hook path is assumed; manual chain execution remains the fallback.',
+    }),
+    slashCommands: capability({
+      status: 'unknown',
+      command: null,
+      observation:
+        'No file-defined slash command API is assumed; command files remain explicit procedures.',
+    }),
+    pluginSkillMcp: capability({
+      status: 'confirmed',
+      command: null,
+      observation:
+        'Plugin Skill (`skills/**/SKILL.md`) and plugin MCP (`*.mcp.json`) formats are confirmed from official MiniMax documentation; local plugin installation was not executed by this probe.',
+    }),
+    nativeTeam: capability({
+      status: 'partial',
+      command: null,
+      observation:
+        'Official Team documentation describes Leader, Worker, and Verifier; programmatic bridge controls were not executed and remain unverified.',
+    }),
+  };
+}
+
+function restoreSpawnArgs(command, workdir) {
+  return command.slice(1).map((argument) => (argument === '<WORKDIR>' ? workdir : argument));
+}
+
+function runMcode(mcode, args, workdir, redact, isolatedHome) {
+  const result = spawnSync(mcode, args, {
+    cwd: workdir,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HOME: isolatedHome,
+    },
+  });
+  const exitCode = Number.isInteger(result.status) ? result.status : null;
+  let observation = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
+  if (result.error?.code === 'ENOENT') {
+    observation = 'Executable not found.';
+  } else if (result.error) {
+    observation = result.error.message;
+  }
+  return {
+    exitCode,
+    observation: redact(observation || `Exited with code ${exitCode}.`),
+    stdout: result.stdout ?? '',
+  };
+}
+
+function runInit(mcode, workdir, redact, isolatedHome) {
+  return runMcode(mcode, ['init', workdir], workdir, redact, isolatedHome);
+}
+
+const AUTH_SEED_ENTRIES = ['cli-auth', 'local-runtime.auth.json', 'config.yaml'];
+
+function seedIsolatedAuth(operatorHome, isolatedHome) {
+  const sourceRoot = path.join(operatorHome, '.minimax');
+  const destinationRoot = path.join(isolatedHome, '.minimax');
+  if (!fs.existsSync(sourceRoot)) return { seeded: false, entries: [] };
+  const seeded = [];
+  for (const entry of AUTH_SEED_ENTRIES) {
+    const source = path.join(sourceRoot, entry);
+    if (!fs.existsSync(source)) continue;
+    const destination = path.join(destinationRoot, entry);
+    fs.cpSync(source, destination, { recursive: true });
+    seeded.push(entry);
+  }
+  return { seeded: seeded.length > 0, entries: seeded };
+}
+
+function copyProbeInputs(workdir, relativeInputs) {
+  for (const relativeInput of relativeInputs) {
+    const source = path.join(fixtureDirectory, relativeInput);
+    const destination = path.join(workdir, relativeInput);
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    fs.copyFileSync(source, destination);
+  }
+}
+
+function extractSentinels(value) {
+  const text = typeof value === 'string' ? value : JSON.stringify(value ?? '');
+  return [...new Set(text.match(/MAVIS_[A-Z_]+_SENTINEL/g) ?? [])];
+}
+
+function parseStructuredOutput(stdout) {
+  const parsed = JSON.parse(stdout);
+  if (parsed?.status === 'ok' && Array.isArray(parsed.sentinels)) {
+    return parsed;
+  }
+  if (parsed?.type === 'exec.result') {
+    const sentinels = extractSentinels(parsed.output);
+    if (parsed.status === 'succeeded' || sentinels.length > 0) {
+      return {
+        status: 'ok',
+        sentinels,
+        observation: `mcode wrapper status ${parsed.status}`,
+      };
+    }
+    throw new Error(`exec.result status ${parsed.status}`);
+  }
+  throw new Error('Structured output did not match a known probe or mcode wrapper shape');
+}
+
+function updateExecutionCapability(target, result, status, observation) {
+  target.status = status;
+  target.exitCode = result.exitCode;
+  target.observation = observation;
+  target.executed = true;
+}
+
+function writeEvidence(evidence, exitCode) {
+  process.stdout.write(`${JSON.stringify(evidence, null, 2)}\n`);
+  process.exitCode = exitCode;
+}
+
+function sentinelSet(parsed) {
+  return new Set(parsed?.sentinels ?? []);
+}
+
+let options;
+try {
+  options = parseArguments(process.argv.slice(2));
+} catch (error) {
+  process.stdout.write(
+    `${JSON.stringify({ schemaVersion: 1, probeStatus: 'blocked', error: error.message }, null, 2)}\n`,
+  );
+  process.exitCode = 2;
+}
+
+if (options) {
+  const { mcode, workdir } = options;
+  let isolatedHome;
+  try {
+    isolatedHome = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-probe-home-'));
+    const operatorHome = process.env.HOME || os.homedir();
+    const authSeed = seedIsolatedAuth(operatorHome, isolatedHome);
+    const redact = createRedactor({ mcode, workdir, isolatedHome });
+    const capabilities = createCapabilities(redact, mcode, workdir);
+    const evidence = {
+      schemaVersion: 1,
+      probeStatus: 'completed',
+      cli: {
+        executable: '<MCODE>',
+        version: null,
+      },
+      os: {
+        platform: os.platform(),
+        release: os.release(),
+        arch: os.arch(),
+      },
+      workdir: '<WORKDIR>',
+      authSeed: {
+        seeded: authSeed.seeded,
+        entries: authSeed.entries,
+      },
+      capabilities,
+    };
+
+    fs.mkdirSync(workdir, { recursive: true });
+    if (fs.readdirSync(workdir).length > 0) {
+      evidence.probeStatus = 'blocked';
+      capabilities.freshInit.observation = 'Workdir must be empty before the probe starts.';
+      writeEvidence(evidence, 2);
+    } else {
+      const version = runMcode(mcode, ['--version'], workdir, redact, isolatedHome);
+      const versionText = redact(version.stdout).split(/\r?\n/, 1)[0] || null;
+      updateExecutionCapability(
+        capabilities.cliVersion,
+        version,
+        version.exitCode === 0 && versionText ? 'confirmed' : 'unknown',
+        version.exitCode === 0 && versionText ? versionText : version.observation,
+      );
+
+      if (capabilities.cliVersion.status !== 'confirmed') {
+        evidence.probeStatus = 'blocked';
+        writeEvidence(evidence, 2);
+      } else {
+        evidence.cli.version = versionText;
+
+        const help = runMcode(mcode, ['--help'], workdir, redact, isolatedHome);
+        updateExecutionCapability(
+          capabilities.cliHelp,
+          help,
+          help.exitCode === 0 ? 'confirmed' : 'unknown',
+          help.observation,
+        );
+
+        const init = runInit(mcode, workdir, redact, isolatedHome);
+        updateExecutionCapability(
+          capabilities.freshInit,
+          init,
+          init.exitCode === 0 ? 'confirmed' : 'unknown',
+          init.observation,
+        );
+
+        copyProbeInputs(workdir, LIBRARY_INPUTS);
+
+        const nativeArgs = restoreSpawnArgs(capabilities.nativeProjectRules.command, workdir);
+        const nativeResult = runMcode(mcode, nativeArgs, workdir, redact, isolatedHome);
+        let nativeOutput = null;
+        try {
+          nativeOutput = nativeResult.exitCode === 0 ? parseStructuredOutput(nativeResult.stdout) : null;
+        } catch (error) {
+          nativeResult.observation = redact(error.message);
+        }
+        const nativeSentinels = sentinelSet(nativeOutput);
+        const nativeObservation = redact(nativeOutput?.observation ?? nativeResult.observation);
+        updateExecutionCapability(
+          capabilities.nativeProjectRules,
+          nativeResult,
+          nativeSentinels.has('MAVIS_RULE_SENTINEL') ? 'confirmed' : 'unknown',
+          nativeSentinels.has('MAVIS_RULE_SENTINEL')
+            ? 'Rule sentinel returned without an explicit root AGENTS.md reference.'
+            : nativeObservation,
+        );
+        updateExecutionCapability(
+          capabilities.nativeWorkspaceSkills,
+          nativeResult,
+          nativeSentinels.has('MAVIS_SKILL_SENTINEL') ? 'confirmed' : 'unknown',
+          nativeSentinels.has('MAVIS_SKILL_SENTINEL')
+            ? 'Skill sentinel returned without an explicit root AGENTS.md reference.'
+            : nativeObservation,
+        );
+        updateExecutionCapability(
+          capabilities.nativeWorkspaceAgents,
+          nativeResult,
+          nativeSentinels.has('MAVIS_AGENT_FILE_SENTINEL') ? 'confirmed' : 'unknown',
+          nativeSentinels.has('MAVIS_AGENT_FILE_SENTINEL')
+            ? 'Agent sentinel returned without mcode exec --file.'
+            : nativeObservation,
+        );
+
+        copyProbeInputs(workdir, ['AGENTS.md']);
+
+        const rootArgs = restoreSpawnArgs(capabilities.rootAgents.command, workdir);
+        const rootResult = runMcode(mcode, rootArgs, workdir, redact, isolatedHome);
+        let rootOutput = null;
+        try {
+          rootOutput = rootResult.exitCode === 0 ? parseStructuredOutput(rootResult.stdout) : null;
+        } catch (error) {
+          rootResult.observation = redact(error.message);
+        }
+        const rootSentinels = sentinelSet(rootOutput);
+        updateExecutionCapability(
+          capabilities.rootAgents,
+          rootResult,
+          rootSentinels.has('MAVIS_AGENTS_SENTINEL') ? 'confirmed' : 'unknown',
+          redact(rootOutput?.observation ?? rootResult.observation),
+        );
+        updateExecutionCapability(
+          capabilities.referencedRule,
+          rootResult,
+          rootSentinels.has('MAVIS_RULE_SENTINEL') ? 'confirmed' : 'unknown',
+          rootSentinels.has('MAVIS_RULE_SENTINEL')
+            ? 'Rule sentinel returned through the explicit root AGENTS.md reference.'
+            : rootResult.observation,
+        );
+        updateExecutionCapability(
+          capabilities.referencedSkill,
+          rootResult,
+          rootSentinels.has('MAVIS_SKILL_SENTINEL') ? 'confirmed' : 'unknown',
+          rootSentinels.has('MAVIS_SKILL_SENTINEL')
+            ? 'Skill sentinel returned through the explicit root AGENTS.md reference.'
+            : rootResult.observation,
+        );
+        updateExecutionCapability(
+          capabilities.structuredOutput,
+          rootResult,
+          rootOutput ? 'confirmed' : 'unknown',
+          rootOutput
+            ? 'Output parsed as JSON and matched the required probe fields.'
+            : rootResult.observation,
+        );
+
+        const roleArgs = restoreSpawnArgs(capabilities.explicitAgentFile.command, workdir);
+        const roleResult = runMcode(mcode, roleArgs, workdir, redact, isolatedHome);
+        let roleOutput = null;
+        try {
+          roleOutput = roleResult.exitCode === 0 ? parseStructuredOutput(roleResult.stdout) : null;
+        } catch (error) {
+          roleResult.observation = redact(error.message);
+        }
+        updateExecutionCapability(
+          capabilities.explicitAgentFile,
+          roleResult,
+          roleOutput?.sentinels.includes('MAVIS_AGENT_FILE_SENTINEL') ? 'confirmed' : 'unknown',
+          redact(roleOutput?.observation ?? roleResult.observation),
+        );
+
+        const hardNoGoObserved =
+          capabilities.rootAgents.status !== 'confirmed' ||
+          capabilities.explicitAgentFile.status !== 'confirmed' ||
+          capabilities.structuredOutput.status !== 'confirmed';
+        if (hardNoGoObserved) evidence.probeStatus = 'blocked';
+        writeEvidence(evidence, hardNoGoObserved ? 2 : 0);
+      }
+    }
+  } finally {
+    if (isolatedHome) {
+      fs.rmSync(isolatedHome, { recursive: true, force: true });
+    }
+  }
+}