ma-agents 3.6.2 → 3.9.0

package/test/opencode-json-merge.test.js

@@ -1,318 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for Story 9.3: JSON Injection — Merge Into Existing opencode.json
- *
- * Validates that updateAgentInstructions() merges skill instructions into an
- * existing opencode.json without destroying user configuration.
- *
- * Updated: instructions entries are now plain strings (OpenCode schema compliance).
- * Legacy object-format entries ({ _source, text }) are cleaned up during merge.
- */
-'use strict';
-
-const assert = require('assert');
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
-
-let passed = 0;
-let failed = 0;
-const errors = [];
-
-async function asyncTest(name, fn) {
-  try {
-    await fn();
-    console.log(`  ✓ ${name}`);
-    passed++;
-  } catch (err) {
-    console.error(`  ✗ ${name}: ${err.message}`);
-    failed++;
-    errors.push({ name, error: err.message });
-  }
-}
-
-// Load functions under test
-const {
-  _testUpdateAgentInstructions: updateFn,
-  _MA_AGENTS_SOURCE: MA_AGENTS_SOURCE
-} = require('../lib/installer');
-
-// Helper: create a temporary directory, run fn, then clean up
-async function withTempDir(fn) {
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ma-agents-json-merge-test-'));
-  try {
-    await fn(tmpDir);
-  } finally {
-    await fs.remove(tmpDir);
-  }
-}
-
-// Helper: build a mock OpenCode agent pointing to a given projectRoot
-function createOpenCodeAgent(projectRoot) {
-  return {
-    id: 'opencode',
-    name: 'OpenCode',
-    category: 'ide',
-    instructionFiles: ['opencode.json'],
-    injectionStrategy: { position: 'json-merge', targetKey: 'instructions' },
-    getProjectPath: () => path.join(projectRoot, '.opencode', 'skills'),
-    getGlobalPath: () => path.join(os.homedir(), '.opencode', 'skills')
-  };
-}
-
-// Helper: check if an entry is an ma-agents entry (new string or legacy object format)
-function isMaEntry(entry) {
-  return (typeof entry === 'string' && entry.startsWith(`[${MA_AGENTS_SOURCE}]`)) ||
-    (typeof entry === 'object' && entry != null && entry._source === MA_AGENTS_SOURCE);
-}
-
-// Helper: create a fixture opencode.json with mixed entries and extra top-level key
-// Includes a legacy object-format ma-agents entry to test backward compat cleanup
-async function writeFixture(filePath) {
-  const fixture = {
-    theme: 'dark',
-    instructions: [
-      'user instruction',
-      'another user instruction',
-      { _source: MA_AGENTS_SOURCE, text: 'old instruction' }
-    ]
-  };
-  await fs.writeFile(filePath, JSON.stringify(fixture, null, 2), 'utf-8');
-}
-
-// ─── Merge path tests (file present) ─────────────────────────────────────────
-
-console.log('\nStory 9.3 — JSON injection: file-present merge path');
-
-(async () => {
-  await asyncTest('9.3.1: user entries are preserved (count = 2)', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      const userEntries = parsed.instructions.filter(e => !isMaEntry(e));
-      assert.strictEqual(userEntries.length, 2,
-        `Expected 2 user entries, got ${userEntries.length}`);
-    });
-  });
-
-  await asyncTest('9.3.2: original user entry values are intact', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      const userEntries = parsed.instructions.filter(e => !isMaEntry(e));
-      assert.strictEqual(userEntries[0], 'user instruction',
-        `First user entry should be "user instruction", got: ${JSON.stringify(userEntries[0])}`);
-      assert.strictEqual(userEntries[1], 'another user instruction',
-        `Second user entry should be "another user instruction", got: ${JSON.stringify(userEntries[1])}`);
-    });
-  });
-
-  await asyncTest('9.3.3: legacy object-format ma-agents entry is removed', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      const legacyEntry = parsed.instructions.find(
-        e => typeof e === 'object' && e != null && e._source === MA_AGENTS_SOURCE
-      );
-      assert.strictEqual(legacyEntry, undefined,
-        'Legacy object-format ma-agents entry should have been removed');
-    });
-  });
-
-  await asyncTest('9.3.4: fresh ma-agents entry is a plain string', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      const freshEntries = parsed.instructions.filter(e => isMaEntry(e));
-      assert.ok(freshEntries.length > 0,
-        'At least one fresh ma-agents entry should be present');
-      for (const entry of freshEntries) {
-        assert.strictEqual(typeof entry, 'string',
-          `Fresh entry should be a plain string, got ${typeof entry}: ${JSON.stringify(entry)}`);
-        assert.ok(entry.startsWith(`[${MA_AGENTS_SOURCE}]`),
-          `Fresh entry should start with [${MA_AGENTS_SOURCE}]`);
-      }
-    });
-  });
-
-  await asyncTest('9.3.5: fresh ma-agents entries are at the end', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      const instructions = parsed.instructions;
-      let lastUserIdx = -1;
-      let firstMaIdx = -1;
-      for (let i = 0; i < instructions.length; i++) {
-        if (isMaEntry(instructions[i])) {
-          if (firstMaIdx === -1) firstMaIdx = i;
-        } else {
-          lastUserIdx = i;
-        }
-      }
-      assert.ok(firstMaIdx > lastUserIdx,
-        `Fresh ma-agents entries (first at index ${firstMaIdx}) should appear after all user entries (last at index ${lastUserIdx})`);
-    });
-  });
-
-  await asyncTest('9.3.6: theme key is preserved with value "dark"', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      assert.strictEqual(parsed.theme, 'dark',
-        `Expected theme to be "dark", got: ${JSON.stringify(parsed.theme)}`);
-    });
-  });
-
-  await asyncTest('9.3.7: output is valid JSON', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const raw = fs.readFileSync(filePath, 'utf-8');
-      let parsed;
-      try {
-        parsed = JSON.parse(raw);
-      } catch (e) {
-        throw new Error(`File content is not valid JSON: ${e.message}\nContent: ${raw}`);
-      }
-      assert.ok(parsed !== null && typeof parsed === 'object', 'Parsed result should be an object');
-    });
-  });
-
-  await asyncTest('9.3.8: no .tmp file left on disk after successful write', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const tmpPath = filePath + '.tmp';
-      assert.strictEqual(fs.existsSync(tmpPath), false,
-        '.tmp file should not exist after successful write');
-    });
-  });
-
-  await asyncTest('9.3.9: file with no instructions key gets key initialized before merge', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      // Write a valid JSON with no instructions key
-      await fs.writeFile(filePath, JSON.stringify({ theme: 'light' }, null, 2), 'utf-8');
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      assert.ok(Array.isArray(parsed.instructions),
-        'instructions key should be initialized as an array');
-      assert.ok(parsed.instructions.length > 0,
-        'instructions array should have fresh ma-agents entries');
-      assert.strictEqual(parsed.theme, 'light',
-        'Other keys should be preserved unchanged');
-    });
-  });
-
-  await asyncTest('9.3.10: re-running installer replaces old ma-agents entries, not accumulates', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      // Run twice
-      await updateFn(agent, tmpDir);
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      const maEntries = parsed.instructions.filter(e => isMaEntry(e));
-      // Should have same count as after first run (no accumulation)
-      await withTempDir(async (tmpDir2) => {
-        const agent2 = createOpenCodeAgent(tmpDir2);
-        const filePath2 = path.join(tmpDir2, 'opencode.json');
-        await writeFixture(filePath2);
-        await updateFn(agent2, tmpDir2);
-        const parsed2 = JSON.parse(fs.readFileSync(filePath2, 'utf-8'));
-        const maEntries2 = parsed2.instructions.filter(e => isMaEntry(e));
-        assert.strictEqual(maEntries.length, maEntries2.length,
-          `Running installer twice should not accumulate ma-agents entries. Got ${maEntries.length} after 2 runs, ${maEntries2.length} after 1 run`);
-      });
-    });
-  });
-
-  await asyncTest('9.3.11: null entries in instructions array are filtered out safely (null-guard)', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      // Hand-edited file with null entry, a valid user entry, and a legacy ma-agents object
-      const fixture = { instructions: [null, 'user entry', { _source: MA_AGENTS_SOURCE, text: 'old ma-entry' }] };
-      await fs.writeFile(filePath, JSON.stringify(fixture, null, 2), 'utf-8');
-
-      await updateFn(agent, tmpDir);
-
-      const result = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      // null should be filtered out — only user entry + fresh ma-agents string remain
-      assert.ok(!result.instructions.includes(null), 'null entry should be removed from instructions array');
-      const userEntries = result.instructions.filter(e => e != null && !isMaEntry(e));
-      assert.strictEqual(userEntries.length, 1, 'valid user entry should be preserved');
-      const maEntries = result.instructions.filter(e => isMaEntry(e));
-      assert.ok(maEntries.length > 0, 'fresh ma-agents entry should be present');
-      assert.strictEqual(typeof maEntries[0], 'string', 'fresh ma-agents entry should be a plain string');
-    });
-  });
-
-  await asyncTest('9.3.12: all entries in output are plain strings (OpenCode schema compliance)', async () => {
-    await withTempDir(async (tmpDir) => {
-      const agent = createOpenCodeAgent(tmpDir);
-      const filePath = path.join(tmpDir, 'opencode.json');
-      await writeFixture(filePath);
-
-      await updateFn(agent, tmpDir);
-
-      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      for (const entry of parsed.instructions) {
-        assert.strictEqual(typeof entry, 'string',
-          `All entries should be plain strings for OpenCode compatibility, got ${typeof entry}: ${JSON.stringify(entry)}`);
-      }
-    });
-  });
-
-  // Print summary
-  console.log(`\n${passed} passed, ${failed} failed`);
-  if (errors.length > 0) {
-    console.log('\nFailed tests:');
-    errors.forEach(e => console.log(`  - ${e.name}: ${e.error}`));
-  }
-  if (failed > 0) process.exit(1);
-})();

package/test/portable-paths.test.js

@@ -1,268 +0,0 @@
-#!/usr/bin/env node
-/**
- * Tests for Story 16.7: Portable Path Storage
- * Tests toPortablePath(), resolveStoredPath(), and round-trip write/read with relative paths
- */
-'use strict';
-
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
-
-let passed = 0;
-let failed = 0;
-const errors = [];
-
-function test(name, fn) {
-  try {
-    fn();
-    console.log(`  \u2713 ${name}`);
-    passed++;
-  } catch (err) {
-    console.error(`  \u2717 ${name}: ${err.message}`);
-    failed++;
-    errors.push({ name, error: err.message });
-  }
-}
-
-// ─── Load module ─────────────────────────────────────────────────────────────
-let toPortablePath, resolveStoredPath, normalizePath, writeProjectLayoutYaml, writeRepoLayoutConfig, readExistingLayout;
-try {
-  ({ toPortablePath, resolveStoredPath, normalizePath, writeProjectLayoutYaml, writeRepoLayoutConfig, readExistingLayout } = require('../bin/cli.js'));
-} catch (e) {
-  console.error('\n  FATAL: Cannot load exports from cli.js');
-  console.error(' ', e.message);
-  process.exit(1);
-}
-
-// Helper
-function withTmpDir() {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-test-'));
-  const origCwd = process.cwd();
-  process.chdir(tmpDir);
-  return { tmpDir, cleanup() { process.chdir(origCwd); fs.rmSync(tmpDir, { recursive: true, force: true }); } };
-}
-
-// ─── toPortablePath ────────────────────────────────────────────────────────
-console.log('\ntoPortablePath');
-
-test('sibling path stored as relative: d:/Code/kb from d:/Code/agents becomes ../kb', () => {
-  const result = toPortablePath('d:/Code/kb', 'd:/Code/agents');
-  assert.strictEqual(result.portable, '../kb');
-  assert.strictEqual(result.isAbsolute, false);
-});
-
-test('nested relative works: ../../other/kb', () => {
-  const result = toPortablePath('/home/user/other/kb', '/home/user/projects/myapp');
-  assert.strictEqual(result.portable, '../../other/kb');
-  assert.strictEqual(result.isAbsolute, false);
-});
-
-test('dot path stays as dot', () => {
-  const result = toPortablePath('.', '/any/root');
-  assert.strictEqual(result.portable, '.');
-  assert.strictEqual(result.isAbsolute, false);
-});
-
-test('null/empty returns dot', () => {
-  const result = toPortablePath('', '/any/root');
-  assert.strictEqual(result.portable, '.');
-  assert.strictEqual(result.isAbsolute, false);
-});
-
-test('deeply nested (>3 levels up) falls back to absolute', () => {
-  const result = toPortablePath('/a/b', '/a/b/c/d/e/f');
-  assert.strictEqual(result.isAbsolute, true, 'should be marked absolute');
-  // Path should be the normalized absolute path
-  assert.ok(!result.portable.startsWith('.'), 'should not be relative');
-});
-
-test('same directory returns dot', () => {
-  const result = toPortablePath('/home/user/project', '/home/user/project');
-  assert.strictEqual(result.portable, '.');
-  assert.strictEqual(result.isAbsolute, false);
-});
-
-test('subdirectory becomes simple relative', () => {
-  const result = toPortablePath('/home/user/project/sub', '/home/user/project');
-  assert.strictEqual(result.portable, 'sub');
-  assert.strictEqual(result.isAbsolute, false);
-});
-
-test('backslashes in result are normalized to forward slashes', () => {
-  // On Windows, path.relative may return backslashes
-  const result = toPortablePath('d:\\Code\\kb', 'd:\\Code\\agents');
-  assert.ok(!result.portable.includes('\\'), 'should not contain backslashes');
-});
-
-// ─── resolveStoredPath ─────────────────────────────────────────────────────
-console.log('\nresolveStoredPath');
-
-test('dot path stays as dot', () => {
-  assert.strictEqual(resolveStoredPath('.', '/any/root'), '.');
-});
-
-test('null returns dot (safe default)', () => {
-  assert.strictEqual(resolveStoredPath(null, '/any/root'), '.');
-});
-
-test('absolute path passes through unchanged', () => {
-  assert.strictEqual(resolveStoredPath('/absolute/path', '/any/root'), '/absolute/path');
-});
-
-test('relative path resolved from project root', () => {
-  const result = resolveStoredPath('../kb', '/home/user/project');
-  assert.strictEqual(result, normalizePath(path.resolve('/home/user/project', '../kb')));
-});
-
-test('Windows drive letter path passes through', () => {
-  assert.strictEqual(resolveStoredPath('d:/Code/kb', '/any/root'), 'd:/Code/kb');
-});
-
-// ─── writeProjectLayoutYaml with portable paths ───────────────────────────
-console.log('\nwriteProjectLayoutYaml (portable paths)');
-
-test('writes relative paths for sibling directories', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    const siblingPath = path.join(path.dirname(tmpDir), 'kb-repo');
-    writeProjectLayoutYaml({
-      knowledgebase: { mode: 'local', path: siblingPath },
-      sprintManagement: { mode: 'same', path: '.' }
-    });
-    const content = fs.readFileSync(path.join(tmpDir, '_bmad-output', 'project-layout.yaml'), 'utf-8');
-    assert.ok(content.includes('../kb-repo'), `should contain relative path, got: ${content}`);
-    assert.ok(!content.includes('PORTABILITY'), 'should not have portability warning');
-  } finally {
-    cleanup();
-  }
-});
-
-test('writes dot path unchanged for same-repo', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    writeProjectLayoutYaml({
-      knowledgebase: { mode: 'local', path: '.' },
-      sprintManagement: { mode: 'local', path: path.join(path.dirname(tmpDir), 'sprint') }
-    });
-    const content = fs.readFileSync(path.join(tmpDir, '_bmad-output', 'project-layout.yaml'), 'utf-8');
-    assert.ok(content.includes('path: "."'), `dot path should be preserved, got: ${content}`);
-    assert.ok(content.includes('../sprint'), 'sibling should be relative');
-  } finally {
-    cleanup();
-  }
-});
-
-// ─── writeRepoLayoutConfig with portable paths ────────────────────────────
-console.log('\nwriteRepoLayoutConfig (portable paths)');
-
-test('writes relative paths to config.yaml', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    const configDir = path.join(tmpDir, '_bmad', 'bmm');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(path.join(configDir, 'config.yaml'), '# existing config\n{}');
-    const siblingKb = path.join(path.dirname(tmpDir), 'kb-repo');
-    writeRepoLayoutConfig({
-      knowledgebase: { mode: 'local', path: siblingKb },
-      sprintManagement: { mode: 'same', path: '.' }
-    });
-    const content = fs.readFileSync(path.join(configDir, 'config.yaml'), 'utf-8');
-    assert.ok(content.includes('knowledgebase_path: "../kb-repo"'), `should have relative path, got: ${content}`);
-    assert.ok(content.includes('sprint_management_path: "."'), `dot path preserved, got: ${content}`);
-  } finally {
-    cleanup();
-  }
-});
-
-test('derived artifact paths are relative when base is relative', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    const configDir = path.join(tmpDir, '_bmad', 'bmm');
-    fs.mkdirSync(configDir, { recursive: true });
-    fs.writeFileSync(path.join(configDir, 'config.yaml'), '# config\n{}');
-    const siblingKb = path.join(path.dirname(tmpDir), 'kb-repo');
-    writeRepoLayoutConfig({
-      knowledgebase: { mode: 'local', path: siblingKb },
-      sprintManagement: { mode: 'same', path: '.' }
-    });
-    const content = fs.readFileSync(path.join(configDir, 'config.yaml'), 'utf-8');
-    assert.ok(content.includes('planning_artifacts: "../kb-repo/_bmad-output/planning-artifacts"'),
-      `planning_artifacts should be relative, got: ${content}`);
-    assert.ok(content.includes('implementation_artifacts: "_bmad-output/implementation-artifacts"'),
-      `impl_artifacts should use default for ".", got: ${content}`);
-  } finally {
-    cleanup();
-  }
-});
-
-// ─── Round-trip: write relative → read → resolve to absolute ───────────────
-console.log('\nRound-trip: write relative, read back, resolve to absolute');
-
-test('round-trip: sibling path written as relative, read back as resolved absolute', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    const siblingPath = normalizePath(path.join(path.dirname(tmpDir), 'kb-repo'));
-    writeProjectLayoutYaml({
-      knowledgebase: { mode: 'local', path: siblingPath },
-      sprintManagement: { mode: 'same', path: '.' }
-    });
-    // Verify file has relative path
-    const fileContent = fs.readFileSync(path.join(tmpDir, '_bmad-output', 'project-layout.yaml'), 'utf-8');
-    assert.ok(fileContent.includes('../kb-repo'), 'file should store relative');
-
-    // Read back — should resolve to absolute
-    const result = readExistingLayout();
-    assert.ok(result, 'should read layout');
-    const resolvedKb = normalizePath(result.knowledgebase.path);
-    assert.strictEqual(resolvedKb, siblingPath, `should resolve back to original: got ${resolvedKb}`);
-  } finally {
-    cleanup();
-  }
-});
-
-test('round-trip: dot path stays as dot', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    writeProjectLayoutYaml({
-      knowledgebase: { mode: 'local', path: path.join(path.dirname(tmpDir), 'kb') },
-      sprintManagement: { mode: 'same', path: '.' }
-    });
-    const result = readExistingLayout();
-    assert.strictEqual(result.sprintManagement.path, '.', 'dot should stay as dot');
-  } finally {
-    cleanup();
-  }
-});
-
-test('backward compat: absolute paths in existing files still work', () => {
-  const { tmpDir, cleanup } = withTmpDir();
-  try {
-    // Manually write absolute path (old format)
-    const dir = path.join(tmpDir, '_bmad-output');
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, 'project-layout.yaml'), [
-      'knowledgebase:',
-      '  mode: local',
-      '  path: "/absolute/old/kb"',
-      'sprint_management:',
-      '  mode: same',
-      '  path: "."',
-    ].join('\n'));
-
-    const result = readExistingLayout();
-    assert.ok(result, 'should read layout');
-    assert.strictEqual(result.knowledgebase.path, '/absolute/old/kb', 'absolute path should pass through');
-  } finally {
-    cleanup();
-  }
-});
-
-// ─── Summary ───────────────────────────────────────────────────────────────
-console.log(`\n${passed} passed, ${failed} failed`);
-if (errors.length > 0) {
-  console.log('\nFailed tests:');
-  errors.forEach(e => console.log(`  - ${e.name}: ${e.error}`));
-}
-if (failed > 0) process.exit(1);