ma-agents 2.20.3 → 2.22.0

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

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * Tests for Story 9.4: JSON Injection — Handle Invalid opencode.json Gracefully
+ *
+ * Validates that updateAgentInstructions() recovers non-fatally when
+ * opencode.json contains invalid JSON: logs an error, leaves the file
+ * byte-identical, and continues processing subsequent agents.
+ */
+'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-error-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: build a generic markdown agent (simulates "someOtherAgent")
+function createMarkdownAgent(projectRoot, fileName) {
+  return {
+    id: 'claude-code',
+    name: 'Claude Code',
+    category: 'ide',
+    instructionFiles: [fileName],
+    injectionStrategy: { position: 'top', skipPatterns: [] },
+    getProjectPath: () => path.join(projectRoot, '.claude', 'skills'),
+    getGlobalPath: () => path.join(os.homedir(), '.claude', 'skills')
+  };
+}
+
+// The corrupt JSON fixture content
+const CORRUPT_JSON = 'not valid json {{{';
+
+// ─── Fixture A: corrupt opencode.json ─────────────────────────────────────────
+
+console.log('\nStory 9.4 — JSON error handling: corrupt opencode.json');
+
+(async () => {
+  await asyncTest('9.4.1: file is byte-identical after run with corrupt JSON (not modified)', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      // Write the corrupt fixture
+      await fs.writeFile(filePath, CORRUPT_JSON, 'utf-8');
+      const beforeBytes = fs.readFileSync(filePath);
+
+      await updateFn(agent, tmpDir);
+
+      const afterBytes = fs.readFileSync(filePath);
+      assert.ok(
+        beforeBytes.equals(afterBytes),
+        `File content changed after corrupt-JSON run.\nBefore: ${beforeBytes.toString()}\nAfter:  ${afterBytes.toString()}`
+      );
+    });
+  });
+
+  await asyncTest('9.4.2: console.error is called with the file path on parse failure', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+      await fs.writeFile(filePath, CORRUPT_JSON, 'utf-8');
+
+      const errorMessages = [];
+      const origError = console.error;
+      console.error = (...args) => errorMessages.push(args.join(' '));
+      try {
+        await updateFn(agent, tmpDir);
+      } finally {
+        console.error = origError;
+      }
+
+      assert.ok(errorMessages.length > 0, 'console.error should have been called');
+      const combined = errorMessages.join('\n');
+      assert.ok(
+        combined.includes(filePath),
+        `Error message should contain the file path "${filePath}".\nActual messages: ${combined}`
+      );
+    });
+  });
+
+  await asyncTest('9.4.3: console.error message describes the parse failure', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+      await fs.writeFile(filePath, CORRUPT_JSON, 'utf-8');
+
+      const errorMessages = [];
+      const origError = console.error;
+      console.error = (...args) => errorMessages.push(args.join(' '));
+      try {
+        await updateFn(agent, tmpDir);
+      } finally {
+        console.error = origError;
+      }
+
+      const combined = errorMessages.join('\n');
+      // The message must mention that file was not modified
+      assert.ok(
+        combined.toLowerCase().includes('not modified') || combined.toLowerCase().includes('file not modified'),
+        `Error message should state the file was not modified.\nActual messages: ${combined}`
+      );
+      // The message must include a parse/error description (err.message from JSON.parse)
+      assert.ok(
+        combined.toLowerCase().includes('parse') ||
+        combined.toLowerCase().includes('token') ||
+        combined.toLowerCase().includes('json') ||
+        combined.toLowerCase().includes('unexpected'),
+        `Error message should describe the parse failure.\nActual messages: ${combined}`
+      );
+    });
+  });
+
+  await asyncTest('9.4.4: no .tmp file is left on disk after parse failure', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+      await fs.writeFile(filePath, CORRUPT_JSON, 'utf-8');
+
+      const origError = console.error;
+      console.error = () => {};
+      try {
+        await updateFn(agent, tmpDir);
+      } finally {
+        console.error = origError;
+      }
+
+      const tmpPath = filePath + '.tmp';
+      assert.strictEqual(
+        fs.existsSync(tmpPath),
+        false,
+        '.tmp file should not exist after a parse-failure run'
+      );
+    });
+  });
+
+  // ─── Fixture B: continuation test (CRITICAL) ────────────────────────────────
+
+  console.log('\nStory 9.4 — JSON error handling: continuation after error (Fixture B)');
+
+  await asyncTest('9.4.5: subsequent agent instruction file IS updated after OpenCode parse failure', async () => {
+    await withTempDir(async (tmpDir) => {
+      // 1. Set up OpenCode with corrupt JSON
+      const opencodeAgent = createOpenCodeAgent(tmpDir);
+      const opencodeFilePath = path.join(tmpDir, 'opencode.json');
+      await fs.writeFile(opencodeFilePath, CORRUPT_JSON, 'utf-8');
+
+      // 2. Set up a second markdown agent whose file does not yet exist
+      const otherFileName = '.claude/CLAUDE.md';
+      const otherAgent = createMarkdownAgent(tmpDir, otherFileName);
+      const otherFilePath = path.join(tmpDir, otherFileName);
+
+      // Suppress console.error during this test
+      const origError = console.error;
+      console.error = () => {};
+      try {
+        // 3. Run both agents in sequence — simulating what the install loop does
+        await updateFn(opencodeAgent, tmpDir);
+        await updateFn(otherAgent, tmpDir);
+      } finally {
+        console.error = origError;
+      }
+
+      // 4. OpenCode file must be unchanged (still corrupt)
+      const opencodeBytes = fs.readFileSync(opencodeFilePath, 'utf-8');
+      assert.strictEqual(
+        opencodeBytes,
+        CORRUPT_JSON,
+        'opencode.json should remain byte-identical (corrupt) after error'
+      );
+
+      // 5. The other agent's instruction file MUST have been created/updated
+      assert.ok(
+        fs.existsSync(otherFilePath),
+        `Second agent's instruction file "${otherFileName}" should have been created after OpenCode error`
+      );
+      const otherContent = fs.readFileSync(otherFilePath, 'utf-8');
+      assert.ok(
+        otherContent.includes('MA-AGENTS-START') || otherContent.includes('MANIFEST.yaml'),
+        `Second agent's instruction file should contain injected content.\nActual: ${otherContent}`
+      );
+    });
+  });
+
+  await asyncTest('9.4.6: updateAgentInstructions does not throw on corrupt JSON (non-fatal)', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+      await fs.writeFile(filePath, CORRUPT_JSON, 'utf-8');
+
+      const origError = console.error;
+      console.error = () => {};
+      let threw = false;
+      try {
+        await updateFn(agent, tmpDir);
+      } catch (err) {
+        threw = true;
+      } finally {
+        console.error = origError;
+      }
+
+      assert.strictEqual(
+        threw,
+        false,
+        'updateAgentInstructions() must NOT throw when JSON.parse fails — error must be non-fatal'
+      );
+    });
+  });
+
+  // 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/opencode-json-injection.test.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * Tests for Story 9.2: JSON Injection — Create opencode.json When Absent
+ *
+ * Validates that updateAgentInstructions() creates a valid opencode.json
+ * from scratch when the file does not yet exist, using the json-merge strategy.
+ */
+'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 = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ✗ ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+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-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')
+  };
+}
+
+// ─── Creation path tests (file absent) ───────────────────────────────────────
+
+console.log('\nStory 9.2 — JSON injection: file-absent creation path');
+
+(async () => {
+  await asyncTest('9.2.1: creates opencode.json when file does not exist', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      assert.strictEqual(fs.existsSync(filePath), false, 'Precondition: file must not exist');
+      await updateFn(agent, tmpDir);
+      assert.ok(fs.existsSync(filePath), 'opencode.json should have been created');
+    });
+  });
+
+  await asyncTest('9.2.2: created file is valid JSON', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      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.2.3: created file contains an "instructions" array', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      assert.ok(Array.isArray(parsed.instructions),
+        `Expected "instructions" to be an array, got: ${typeof parsed.instructions}`);
+    });
+  });
+
+  await asyncTest('9.2.4: instructions array is non-empty', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      assert.ok(parsed.instructions.length > 0,
+        'instructions array should have at least one entry');
+    });
+  });
+
+  await asyncTest('9.2.5: every entry has _source === MA_AGENTS_SOURCE', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      for (const entry of parsed.instructions) {
+        assert.strictEqual(entry._source, MA_AGENTS_SOURCE,
+          `Entry _source should be "${MA_AGENTS_SOURCE}", got: "${entry._source}"`);
+      }
+    });
+  });
+
+  await asyncTest('9.2.6: every entry has a non-empty "text" string', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      for (const entry of parsed.instructions) {
+        assert.strictEqual(typeof entry.text, 'string',
+          `Entry "text" should be a string, got: ${typeof entry.text}`);
+        assert.ok(entry.text.length > 0,
+          'Entry "text" should not be empty');
+      }
+    });
+  });
+
+  await asyncTest('9.2.7: no extra top-level keys in the written JSON', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      const keys = Object.keys(parsed);
+      assert.deepStrictEqual(keys, ['instructions'],
+        `Expected only ["instructions"] as top-level keys, got: ${JSON.stringify(keys)}`);
+    });
+  });
+
+  await asyncTest('9.2.8: file uses 2-space indentation', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      // JSON.stringify(data, null, 2) produces lines starting with "  " (2 spaces) for first level
+      assert.ok(raw.includes('  "instructions"'),
+        'File should use 2-space indentation (line should start with "  \\"instructions\\"")\nActual content:\n' + raw);
+    });
+  });
+
+  await asyncTest('9.2.9: instruction text contains skill manifest reference', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      await updateFn(agent, tmpDir);
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      const allText = parsed.instructions.map(e => e.text).join('\n');
+      assert.ok(allText.includes('MANIFEST.yaml'),
+        'Instruction text should reference MANIFEST.yaml');
+    });
+  });
+
+  await asyncTest('9.2.10: MA_AGENTS_SOURCE constant is "ma-agents"', () => {
+    assert.strictEqual(MA_AGENTS_SOURCE, 'ma-agents',
+      `MA_AGENTS_SOURCE should equal "ma-agents", got: "${MA_AGENTS_SOURCE}"`);
+  });
+
+  await asyncTest('9.2.11: non-json-merge agents are not affected (falls through to markdown logic)', async () => {
+    await withTempDir(async (tmpDir) => {
+      // A regular markdown agent — should not produce a JSON file
+      const markdownAgent = {
+        id: 'claude-code',
+        name: 'Claude Code',
+        category: 'ide',
+        instructionFiles: ['.claude/CLAUDE.md'],
+        injectionStrategy: { position: 'top', skipPatterns: [] },
+        getProjectPath: () => path.join(tmpDir, '.claude', 'skills'),
+        getGlobalPath: () => path.join(os.homedir(), '.claude', 'skills')
+      };
+      await updateFn(markdownAgent, tmpDir);
+      // Should NOT create opencode.json
+      assert.strictEqual(fs.existsSync(path.join(tmpDir, 'opencode.json')), false,
+        'Should not create opencode.json for non-json-merge agents');
+      // Should create the markdown file instead
+      assert.ok(fs.existsSync(path.join(tmpDir, '.claude', 'CLAUDE.md')),
+        'Markdown agent file should be created');
+    });
+  });
+
+  await asyncTest('9.2.12: file present — user entries preserved, fresh ma-agents entries appended (Story 9.3)', async () => {
+    await withTempDir(async (tmpDir) => {
+      const agent = createOpenCodeAgent(tmpDir);
+      const filePath = path.join(tmpDir, 'opencode.json');
+
+      // Pre-create a file with a single user entry
+      const existingContent = { instructions: [{ _source: 'user', text: 'user instruction' }] };
+      await fs.writeFile(filePath, JSON.stringify(existingContent, null, 2), 'utf-8');
+
+      await updateFn(agent, tmpDir);
+
+      // Story 9.3 merge: user entry preserved, fresh ma-agents entries appended
+      const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+      const userEntries = parsed.instructions.filter(e => e._source !== MA_AGENTS_SOURCE);
+      const maEntries = parsed.instructions.filter(e => e._source === MA_AGENTS_SOURCE);
+      assert.strictEqual(userEntries.length, 1,
+        'Existing user entry should be preserved');
+      assert.strictEqual(userEntries[0]._source, 'user',
+        'User entry _source should remain "user"');
+      assert.ok(maEntries.length > 0,
+        'Fresh ma-agents entries should be appended');
+    });
+  });
+
+  // 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);
+})();