@bonesofspring/ai-rules 0.2.22 → 0.2.24

package/scripts/test-cli-init-clean.mjs

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+/**
+ * CLI init/clean goldens and Mavis P0 scenarios.
+ */
+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';
+import { runInit, snapshotInstall } from './lib/cli-golden.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageDirectory = path.resolve(scriptDirectory, '..');
+const cli = path.join(packageDirectory, 'bin', 'cli.js');
+const goldenRoot = path.join(scriptDirectory, 'fixtures', 'cli-golden');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function runClean(cwd, tool) {
+  return execFileSync(process.execPath, [cli, 'clean', tool, '--cwd', cwd], {
+    encoding: 'utf8',
+  });
+}
+
+function runCli(cwd, args, env = {}) {
+  try {
+    return {
+      status: 0,
+      stdout: execFileSync(process.execPath, [cli, ...args, '--cwd', cwd], {
+        encoding: 'utf8',
+        env: { ...process.env, ...env },
+      }),
+    };
+  } catch (error) {
+    return {
+      status: error.status ?? 1,
+      stdout: `${error.stdout || ''}`,
+      stderr: `${error.stderr || ''}`,
+    };
+  }
+}
+
+function assertGolden(tool, preset) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `ai-rules-golden-check-${tool}-`));
+  try {
+    runInit(cli, tmp, tool, preset);
+    const expected = readJson(path.join(goldenRoot, tool, `${preset}.json`));
+    const actual = snapshotInstall(tmp);
+    if (tool === 'mavis') {
+      delete actual['.mavis/.ai-rules-install.json'];
+      delete expected.files['.mavis/.ai-rules-install.json'];
+    }
+    assert.deepEqual(actual, expected.files, `${tool}/${preset} golden drifted`);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+function listHomeMinimax(home) {
+  const root = path.join(home, '.minimax');
+  if (!fs.existsSync(root)) {
+    return [];
+  }
+  const out = [];
+  const visit = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      out.push(path.relative(root, full));
+      if (entry.isDirectory()) {
+        visit(full);
+      }
+    }
+  };
+  visit(root);
+  return out.sort();
+}
+
+assertGolden('cursor', 'next');
+assertGolden('claude', 'next');
+
+const isolatedHome = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-home-'));
+fs.mkdirSync(path.join(isolatedHome, '.minimax'));
+const homeBefore = listHomeMinimax(isolatedHome);
+
+const fresh = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-fresh-'));
+const initOut = execFileSync(
+  process.execPath,
+  [cli, 'init', 'mavis', '--preset', 'next', '--cwd', fresh],
+  { encoding: 'utf8', env: { ...process.env, HOME: isolatedHome } },
+);
+assert.match(initOut, /\.mavis installed/);
+assert.match(initOut, /do not write ~\/\.minimax\/mcp\.json/i);
+assert.equal(fs.existsSync(path.join(fresh, 'AGENTS.md')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'AGENTS.md')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'rules', 'next-app-core.md')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'hooks', 'chain-team-phases.sh')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'mcp.json')), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', 'adapter-map.json')), false);
+assert.equal(fs.existsSync(path.join(fresh, 'docs', 'specs', 'INDEX.md')), true);
+const manifest = readJson(path.join(fresh, '.mavis', '.ai-rules-install.json'));
+assert.equal(manifest.schemaVersion, 1);
+assert.equal(manifest.platform, 'mavis');
+assert.equal(manifest.preset, 'next');
+assert.ok(manifest.managedFiles['AGENTS.md']);
+assert.ok(manifest.shippedMcpServerIds.includes('context7'));
+assert.equal(manifest.docsSeed.seeded, true);
+
+const existingAgents = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-agents-'));
+fs.writeFileSync(path.join(existingAgents, 'AGENTS.md'), '# consumer agents\n');
+runInit(cli, existingAgents, 'mavis', 'next');
+assert.match(fs.readFileSync(path.join(existingAgents, 'AGENTS.md'), 'utf8'), /Mavis compatibility entry/);
+
+const specsExist = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-specs-'));
+fs.mkdirSync(path.join(specsExist, 'docs', 'specs'), { recursive: true });
+runInit(cli, specsExist, 'mavis', 'next');
+assert.equal(fs.existsSync(path.join(specsExist, 'docs', 'specs', 'INDEX.md')), false);
+assert.equal(
+  readJson(path.join(specsExist, '.mavis', '.ai-rules-install.json')).docsSeed.reason,
+  'directory-exists',
+);
+
+writeJson(path.join(fresh, '.mavis', 'mcp.json'), {
+  mcpServers: {
+    context7: {
+      command: 'npx',
+      args: ['-y', '@upstash/context7-mcp@old'],
+      env: { CONTEXT7_API_KEY: 'keep-me' },
+    },
+    storybook: { url: 'http://localhost:6006/mcp' },
+  },
+  localOnly: true,
+});
+const repeat = runInit(cli, fresh, 'mavis', 'next');
+assert.match(repeat, /kept extra servers: storybook/);
+const merged = readJson(path.join(fresh, '.mavis', 'mcp.json'));
+assert.equal(merged.localOnly, true);
+assert.ok(merged.mcpServers.storybook);
+assert.equal(merged.mcpServers.context7.env.CONTEXT7_API_KEY, 'keep-me');
+
+merged.localNote = true;
+writeJson(path.join(fresh, '.mavis', 'mcp.json'), merged);
+const modifiedRel = path.join(fresh, '.mavis', 'rules', 'next-app-core.md');
+fs.appendFileSync(modifiedRel, '\n# local overlay note\n');
+runClean(fresh, 'mavis');
+assert.equal(fs.existsSync(modifiedRel), true);
+assert.equal(fs.existsSync(path.join(fresh, '.mavis', '.ai-rules-install.json')), false);
+assert.equal(fs.existsSync(path.join(fresh, 'AGENTS.md')), false);
+assert.ok(readJson(path.join(fresh, '.mavis', 'mcp.json')).mcpServers.storybook);
+assert.equal(readJson(path.join(fresh, '.mavis', 'mcp.json')).mcpServers.context7, undefined);
+assert.equal(readJson(path.join(fresh, '.mavis', 'mcp.json')).localNote, true);
+
+const missing = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-missing-'));
+fs.writeFileSync(path.join(missing, 'keep.txt'), 'safe\n');
+const missingClean = runCli(missing, ['clean', 'mavis']);
+assert.equal(missingClean.status, 1);
+assert.match(`${missingClean.stderr}${missingClean.stdout}`, /nothing removed/);
+assert.equal(fs.readFileSync(path.join(missing, 'keep.txt'), 'utf8'), 'safe\n');
+
+const corrupt = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-corrupt-'));
+fs.mkdirSync(path.join(corrupt, '.mavis'), { recursive: true });
+fs.writeFileSync(path.join(corrupt, '.mavis', '.ai-rules-install.json'), '{not json');
+fs.writeFileSync(path.join(corrupt, '.mavis', 'keep.md'), 'keep\n');
+const corruptClean = runCli(corrupt, ['clean', 'mavis']);
+assert.equal(corruptClean.status, 1);
+assert.equal(fs.readFileSync(path.join(corrupt, '.mavis', 'keep.md'), 'utf8'), 'keep\n');
+
+const twice = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-twice-'));
+runInit(cli, twice, 'mavis', 'next');
+runClean(twice, 'mavis');
+const secondClean = runCli(twice, ['clean', 'mavis']);
+assert.equal(secondClean.status, 1);
+
+const rollback = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-rollback-'));
+fs.writeFileSync(path.join(rollback, 'AGENTS.md'), '# prior\n');
+const fail = runCli(rollback, ['init', 'mavis', '--preset', 'next'], {
+  AI_RULES_MAVIS_FAIL_PHASE: 'write',
+});
+assert.equal(fail.status, 1);
+assert.equal(fs.readFileSync(path.join(rollback, 'AGENTS.md'), 'utf8'), '# prior\n');
+assert.equal(fs.existsSync(path.join(rollback, '.mavis')), false);
+
+const failMcp = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-fail-mcp-'));
+fs.writeFileSync(path.join(failMcp, 'AGENTS.md'), '# prior mcp\n');
+const failMcpRun = runCli(failMcp, ['init', 'mavis', '--preset', 'next'], {
+  AI_RULES_MAVIS_FAIL_PHASE: 'mcp',
+});
+assert.equal(failMcpRun.status, 1);
+assert.equal(fs.readFileSync(path.join(failMcp, 'AGENTS.md'), 'utf8'), '# prior mcp\n');
+assert.equal(fs.existsSync(path.join(failMcp, '.mavis')), false);
+
+const failManifest = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-fail-manifest-'));
+fs.writeFileSync(path.join(failManifest, 'AGENTS.md'), '# prior manifest\n');
+const failManifestRun = runCli(failManifest, ['init', 'mavis', '--preset', 'next'], {
+  AI_RULES_MAVIS_FAIL_PHASE: 'manifest',
+});
+assert.equal(failManifestRun.status, 1);
+assert.equal(fs.readFileSync(path.join(failManifest, 'AGENTS.md'), 'utf8'), '# prior manifest\n');
+assert.equal(fs.existsSync(path.join(failManifest, '.mavis')), false);
+
+const toolFirst = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-tool-first-'));
+execFileSync(process.execPath, [cli, 'mavis', 'init', '--preset', 'next', '--cwd', toolFirst], {
+  encoding: 'utf8',
+});
+assert.equal(fs.existsSync(path.join(toolFirst, '.mavis', 'AGENTS.md')), true);
+
+const unreleased = runCli(fresh, ['init', 'mavis', '--preset', 'nuxt']);
+assert.equal(unreleased.status, 1);
+assert.match(`${unreleased.stderr}${unreleased.stdout}`, /not released yet/i);
+assert.match(`${unreleased.stderr}${unreleased.stdout}`, /Released stacks: next/);
+
+assert.deepEqual(listHomeMinimax(isolatedHome), homeBefore);
+
+const mavisGoldenDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-golden-'));
+runInit(cli, mavisGoldenDir, 'mavis', 'next');
+const mavisFiles = snapshotInstall(mavisGoldenDir);
+delete mavisFiles['.mavis/.ai-rules-install.json'];
+const mavisGoldenPath = path.join(goldenRoot, 'mavis', 'next.json');
+if (!fs.existsSync(mavisGoldenPath)) {
+  writeJson(mavisGoldenPath, {
+    schemaVersion: 1,
+    tool: 'mavis',
+    preset: 'next',
+    files: mavisFiles,
+  });
+} else {
+  const expectedMavis = readJson(mavisGoldenPath);
+  delete expectedMavis.files['.mavis/.ai-rules-install.json'];
+  assert.deepEqual(mavisFiles, expectedMavis.files, 'mavis/next golden drifted');
+}
+
+const ocFresh = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-fresh-'));
+const ocInitOut = execFileSync(
+  process.execPath,
+  [cli, 'init', 'opencode', '--preset', 'next', '--cwd', ocFresh],
+  { encoding: 'utf8' },
+);
+assert.match(ocInitOut, /\.opencode installed/);
+assert.equal(fs.existsSync(path.join(ocFresh, 'AGENTS.md')), true);
+assert.equal(fs.existsSync(path.join(ocFresh, '.opencode', 'AGENTS.md')), true);
+assert.equal(fs.existsSync(path.join(ocFresh, '.opencode', 'rules', 'next-app-core.md')), true);
+assert.equal(fs.existsSync(path.join(ocFresh, '.opencode', 'hooks', 'chain-team-phases.sh')), true);
+assert.equal(fs.existsSync(path.join(ocFresh, 'opencode.json')), true);
+assert.equal(fs.existsSync(path.join(ocFresh, '.opencode', 'adapter-map.json')), false);
+assert.equal(fs.existsSync(path.join(ocFresh, 'docs', 'specs', 'INDEX.md')), true);
+const ocManifest = readJson(path.join(ocFresh, '.opencode', '.ai-rules-install.json'));
+assert.equal(ocManifest.schemaVersion, 1);
+assert.equal(ocManifest.platform, 'opencode');
+assert.equal(ocManifest.preset, 'next');
+assert.ok(ocManifest.managedFiles['AGENTS.md']);
+assert.ok(ocManifest.shippedMcpServerIds.includes('context7'));
+assert.equal(ocManifest.docsSeed.seeded, true);
+
+const ocAgents = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-agents-'));
+fs.writeFileSync(path.join(ocAgents, 'AGENTS.md'), '# consumer agents\n');
+runInit(cli, ocAgents, 'opencode', 'next');
+assert.match(fs.readFileSync(path.join(ocAgents, 'AGENTS.md'), 'utf8'), /OpenCode load map/);
+
+const ocSpecs = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-specs-'));
+fs.mkdirSync(path.join(ocSpecs, 'docs', 'specs'), { recursive: true });
+runInit(cli, ocSpecs, 'opencode', 'next');
+assert.equal(fs.existsSync(path.join(ocSpecs, 'docs', 'specs', 'INDEX.md')), false);
+assert.equal(
+  readJson(path.join(ocSpecs, '.opencode', '.ai-rules-install.json')).docsSeed.reason,
+  'directory-exists',
+);
+
+writeJson(path.join(ocFresh, 'opencode.json'), {
+  $schema: 'https://opencode.ai/config.json',
+  mcp: {
+    context7: {
+      type: 'local',
+      command: ['npx', '-y', '@upstash/context7-mcp@old'],
+      environment: { CONTEXT7_API_KEY: 'keep-me' },
+    },
+    storybook: { type: 'remote', url: 'http://localhost:6006/mcp' },
+  },
+  localOnly: true,
+});
+const ocRepeat = runInit(cli, ocFresh, 'opencode', 'next');
+assert.match(ocRepeat, /kept extra servers: storybook/);
+const ocMerged = readJson(path.join(ocFresh, 'opencode.json'));
+assert.equal(ocMerged.localOnly, true);
+assert.ok(ocMerged.mcp.storybook);
+assert.equal(ocMerged.mcp.context7.environment.CONTEXT7_API_KEY, 'keep-me');
+
+ocMerged.localNote = true;
+writeJson(path.join(ocFresh, 'opencode.json'), ocMerged);
+const ocModifiedRel = path.join(ocFresh, '.opencode', 'rules', 'next-app-core.md');
+fs.appendFileSync(ocModifiedRel, '\n# local overlay note\n');
+runClean(ocFresh, 'opencode');
+assert.equal(fs.existsSync(ocModifiedRel), true);
+assert.equal(fs.existsSync(path.join(ocFresh, '.opencode', '.ai-rules-install.json')), false);
+assert.equal(fs.existsSync(path.join(ocFresh, 'AGENTS.md')), false);
+assert.ok(readJson(path.join(ocFresh, 'opencode.json')).mcp.storybook);
+assert.equal(readJson(path.join(ocFresh, 'opencode.json')).mcp.context7, undefined);
+assert.equal(readJson(path.join(ocFresh, 'opencode.json')).localNote, true);
+
+const ocMissing = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-missing-'));
+fs.writeFileSync(path.join(ocMissing, 'keep.txt'), 'safe\n');
+const ocMissingClean = runCli(ocMissing, ['clean', 'opencode']);
+assert.equal(ocMissingClean.status, 1);
+assert.match(`${ocMissingClean.stderr}${ocMissingClean.stdout}`, /nothing removed/);
+assert.equal(fs.readFileSync(path.join(ocMissing, 'keep.txt'), 'utf8'), 'safe\n');
+
+const ocRollback = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-rollback-'));
+fs.writeFileSync(path.join(ocRollback, 'AGENTS.md'), '# prior\n');
+const ocFail = runCli(ocRollback, ['init', 'opencode', '--preset', 'next'], {
+  AI_RULES_OPENCODE_FAIL_PHASE: 'write',
+});
+assert.equal(ocFail.status, 1);
+assert.equal(fs.readFileSync(path.join(ocRollback, 'AGENTS.md'), 'utf8'), '# prior\n');
+assert.equal(fs.existsSync(path.join(ocRollback, '.opencode')), false);
+
+const ocUnreleased = runCli(ocFresh, ['init', 'opencode', '--preset', 'nuxt']);
+assert.equal(ocUnreleased.status, 1);
+assert.match(`${ocUnreleased.stderr}${ocUnreleased.stdout}`, /not released yet/i);
+
+const ocGoldenDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-golden-'));
+runInit(cli, ocGoldenDir, 'opencode', 'next');
+const ocFiles = snapshotInstall(ocGoldenDir);
+delete ocFiles['.opencode/.ai-rules-install.json'];
+const ocGoldenPath = path.join(goldenRoot, 'opencode', 'next.json');
+if (!fs.existsSync(ocGoldenPath)) {
+  writeJson(ocGoldenPath, {
+    schemaVersion: 1,
+    tool: 'opencode',
+    preset: 'next',
+    files: ocFiles,
+  });
+} else {
+  const expectedOc = readJson(ocGoldenPath);
+  delete expectedOc.files['.opencode/.ai-rules-install.json'];
+  assert.deepEqual(ocFiles, expectedOc.files, 'opencode/next golden drifted');
+}
+
+for (const dir of [
+  isolatedHome,
+  fresh,
+  existingAgents,
+  specsExist,
+  missing,
+  corrupt,
+  twice,
+  rollback,
+  failMcp,
+  failManifest,
+  toolFirst,
+  mavisGoldenDir,
+  ocFresh,
+  ocAgents,
+  ocSpecs,
+  ocMissing,
+  ocRollback,
+  ocGoldenDir,
+]) {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+
+console.log('test-cli-init-clean: ok');

package/scripts/test-cli-mcp-merge.mjs

@@ -131,6 +131,29 @@ try {
   assert.ok(restored.mcpServers.playwright);
   fs.rmSync(deletedDir, { recursive: true, force: true });
 
+  const mavisDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-mavis-'));
+  const mavisMcp = path.join(mavisDir, '.mavis', 'mcp.json');
+  writeJson(mavisMcp, {
+    mcpServers: {
+      context7: {
+        command: 'npx',
+        args: ['-y', '@upstash/context7-mcp@old'],
+        env: { CONTEXT7_API_KEY: 'keep-mavis' },
+      },
+      storybook: { url: 'http://localhost:6006/mcp' },
+    },
+    localOnly: true,
+  });
+  const mavisOut = init(mavisDir, 'mavis', 'next');
+  assert.match(mavisOut, /kept extra servers: storybook/);
+  const mavisMerged = readJson(mavisMcp);
+  assert.equal(mavisMerged.localOnly, true);
+  assert.ok(mavisMerged.mcpServers.storybook);
+  assert.equal(mavisMerged.mcpServers.context7.env.CONTEXT7_API_KEY, 'keep-mavis');
+  assert.ok(mavisMerged.mcpServers.playwright);
+  assert.equal(fs.existsSync(path.join(mavisDir, '.minimax')), false);
+  fs.rmSync(mavisDir, { recursive: true, force: true });
+
   console.log('test-cli-mcp-merge: ok');
 } finally {
   fs.rmSync(tmp, { recursive: true, force: true });

package/scripts/test-mavis-context-budget.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * P1 context budget: root AGENTS + .mavis/AGENTS combined nonempty lines ≤ 170.
+ * Critical-policy sentinels must appear in the pair.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadReleasedMavisStacks } from './lib/discover-hooks.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const presetsRoot = path.join(scriptDirectory, '..', 'presets');
+const LINE_CAP = 170;
+const SENTINELS = [
+  'next-app-core',
+  'package-manager',
+  'code-quality-and-refactoring',
+  'ai-local-overlay',
+  '.mavis/AGENTS.md',
+  'status.json',
+  '~/.minimax',
+];
+
+function nonemptyLines(text) {
+  return text.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+}
+
+const stacks = loadReleasedMavisStacks(presetsRoot);
+if (stacks.length === 0) {
+  console.log('ok mavis context-budget: no released stacks');
+  process.exit(0);
+}
+
+let failed = 0;
+for (const stack of stacks) {
+  const root = path.join(presetsRoot, 'mavis', stack);
+  const repoAgents = fs.readFileSync(path.join(root, 'REPO_AGENTS.md'), 'utf8');
+  const mavisAgents = fs.readFileSync(path.join(root, 'MAVIS.md'), 'utf8');
+  const combined = `${repoAgents}\n${mavisAgents}`;
+  const count = nonemptyLines(repoAgents) + nonemptyLines(mavisAgents);
+  if (count > LINE_CAP) {
+    console.error(`FAIL mavis/${stack}: entry nonempty lines ${count} > ${LINE_CAP}`);
+    failed += 1;
+  } else {
+    console.log(`ok mavis/${stack}: entry nonempty lines ${count} (cap ${LINE_CAP})`);
+  }
+  for (const sentinel of SENTINELS) {
+    if (!combined.includes(sentinel)) {
+      console.error(`FAIL mavis/${stack}: missing critical sentinel ${sentinel}`);
+      failed += 1;
+    }
+  }
+}
+
+process.exit(failed === 0 ? 0 : 1);