ma-agents 3.2.0 → 3.4.0

package/test/roo-code-agent.test.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * Tests for Story 18.1: Register Roo Code Agent in Registry
+ *
+ * Validates that the roo-code agent entry conforms to the required schema
+ * and resolves correctly through the existing config-driven registry pattern.
+ */
+'use strict';
+
+const assert = require('assert');
+
+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 });
+  }
+}
+
+const { getAllAgents, getAgent, getAgentsByCategory } = require('../lib/agents');
+const allAgents = getAllAgents();
+const rooCode = getAgent('roo-code');
+
+// --- Schema validation ---
+
+console.log('\nRoo Code agent schema validation');
+
+test('roo-code agent exists in registry', () => {
+  assert.ok(rooCode, 'roo-code agent should exist in the registry');
+});
+
+test('id is "roo-code"', () => {
+  assert.strictEqual(rooCode.id, 'roo-code');
+});
+
+test('name is "Roo Code"', () => {
+  assert.strictEqual(rooCode.name, 'Roo Code');
+});
+
+test('category is "ide"', () => {
+  assert.strictEqual(rooCode.category, 'ide');
+});
+
+test('getProjectPath is a function', () => {
+  assert.strictEqual(typeof rooCode.getProjectPath, 'function',
+    'getProjectPath should be a function');
+});
+
+test('getGlobalPath is a function', () => {
+  assert.strictEqual(typeof rooCode.getGlobalPath, 'function',
+    'getGlobalPath should be a function');
+});
+
+test('getProjectPath returns path ending in .roo/skills', () => {
+  const projectPath = rooCode.getProjectPath();
+  assert.ok(
+    projectPath.endsWith('.roo/skills') || projectPath.endsWith('.roo\\skills'),
+    `Expected path ending in .roo/skills, got: ${projectPath}`
+  );
+});
+
+test('getGlobalPath returns a non-empty string', () => {
+  const globalPath = rooCode.getGlobalPath();
+  assert.strictEqual(typeof globalPath, 'string');
+  assert.ok(globalPath.length > 0, 'getGlobalPath should return a non-empty string');
+});
+
+test('getGlobalPath contains roo-cline (VS Code extension storage convention)', () => {
+  const globalPath = rooCode.getGlobalPath();
+  assert.ok(
+    globalPath.includes('roo-cline'),
+    `Expected global path to contain 'roo-cline', got: ${globalPath}`
+  );
+});
+
+test('fileExtension is ".md"', () => {
+  assert.strictEqual(rooCode.fileExtension, '.md');
+});
+
+test('description is a non-empty string', () => {
+  assert.strictEqual(typeof rooCode.description, 'string',
+    'description should be a string');
+  assert.ok(rooCode.description.length > 0, 'description should not be empty');
+});
+
+test('description mentions Cline fork lineage', () => {
+  assert.ok(rooCode.description.includes('Cline'),
+    `description should mention Cline fork lineage, got: ${rooCode.description}`);
+});
+
+test('template is "generic"', () => {
+  assert.strictEqual(rooCode.template, 'generic');
+});
+
+test('skillsDir is ".roo/skills"', () => {
+  assert.strictEqual(rooCode.skillsDir, '.roo/skills');
+});
+
+test('instructionFiles is a non-empty array', () => {
+  assert.ok(Array.isArray(rooCode.instructionFiles),
+    'instructionFiles should be an array');
+  assert.ok(rooCode.instructionFiles.length > 0,
+    'instructionFiles should not be empty');
+});
+
+test('instructionFiles targets .roo/rules/ directory', () => {
+  const hasRooRules = rooCode.instructionFiles.some(f =>
+    f.includes('.roo/rules/') || f.includes('.roo\\rules\\')
+  );
+  assert.ok(hasRooRules,
+    `instructionFiles should target .roo/rules/ directory, got: ${rooCode.instructionFiles}`);
+});
+
+test('injectionStrategy is an object', () => {
+  assert.ok(rooCode.injectionStrategy && typeof rooCode.injectionStrategy === 'object',
+    'injectionStrategy should be an object');
+});
+
+test('injectionStrategy.position is "top"', () => {
+  assert.strictEqual(rooCode.injectionStrategy.position, 'top');
+});
+
+// --- Registry resolution ---
+
+console.log('\nRoo Code agent resolution');
+
+test('getAgent("roo-code") returns the agent', () => {
+  const resolved = getAgent('roo-code');
+  assert.ok(resolved, 'getAgent("roo-code") should return an agent object');
+  assert.strictEqual(resolved.id, 'roo-code');
+});
+
+test('roo-code appears in getAllAgents()', () => {
+  const ids = allAgents.map(a => a.id);
+  assert.ok(ids.includes('roo-code'), 'roo-code should appear in getAllAgents()');
+});
+
+test('roo-code is in the ide category', () => {
+  const ideAgents = getAgentsByCategory('ide');
+  const ids = ideAgents.map(a => a.id);
+  assert.ok(ids.includes('roo-code'), 'roo-code should be in ide category');
+});
+
+test('roo-code is distinct from cline', () => {
+  const cline = getAgent('cline');
+  assert.ok(cline, 'cline agent should still exist');
+  assert.notStrictEqual(cline.id, rooCode.id, 'roo-code and cline should be different agents');
+  assert.notStrictEqual(cline.skillsDir, rooCode.skillsDir,
+    'roo-code and cline should use different skills directories');
+});
+
+// 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/roo-code-injection.test.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * Tests for Story 18.3: Roo Code Rules Injection
+ *
+ * Validates that updateAgentInstructions() correctly creates/updates
+ * planning instructions in .roo/rules/00-ma-agents.md for Roo Code.
+ */
+'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(`  \u2713 ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  \u2717 ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+async function asyncTest(name, fn) {
+  try {
+    await fn();
+    console.log(`  \u2713 ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  \u2717 ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+const { _testUpdateAgentInstructions: updateAgentInstructions } = require('../lib/installer');
+const { getAgent } = require('../lib/agents');
+
+// --- Roo Code rules injection tests ---
+
+console.log('\nRoo Code rules injection');
+
+let tmpDir;
+
+async function setup() {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'roo-code-test-'));
+}
+
+async function cleanup() {
+  if (tmpDir) {
+    await fs.remove(tmpDir);
+  }
+}
+
+(async () => {
+  await setup();
+
+  const rooCode = getAgent('roo-code');
+
+  await asyncTest('creates .roo/rules/ directory and 00-ma-agents.md when absent', async () => {
+    const projectRoot = path.join(tmpDir, 'project-create');
+    await fs.ensureDir(projectRoot);
+
+    // Create a mock roo-code agent with paths relative to tmpDir
+    const agent = {
+      ...rooCode,
+      getProjectPath: () => path.join(projectRoot, '.roo', 'skills'),
+      instructionFiles: ['.roo/rules/00-ma-agents.md'],
+      injectionStrategy: { position: 'top', skipPatterns: ['---'] }
+    };
+
+    await updateAgentInstructions(agent, projectRoot);
+
+    const filePath = path.join(projectRoot, '.roo', 'rules', '00-ma-agents.md');
+    assert.ok(await fs.pathExists(filePath), '.roo/rules/00-ma-agents.md should be created');
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    assert.ok(content.includes('<!-- MA-AGENTS-START -->'), 'should contain start marker');
+    assert.ok(content.includes('<!-- MA-AGENTS-END -->'), 'should contain end marker');
+    assert.ok(content.includes('MANIFEST.yaml'), 'should reference MANIFEST.yaml');
+    assert.ok(content.includes('.roo/skills/MANIFEST.yaml'), 'should use .roo/skills/ path');
+  });
+
+  await asyncTest('updates existing content with markers in place (idempotent)', async () => {
+    const projectRoot = path.join(tmpDir, 'project-update');
+    await fs.ensureDir(projectRoot);
+
+    // Pre-create file with old markers
+    const rulesDir = path.join(projectRoot, '.roo', 'rules');
+    await fs.ensureDir(rulesDir);
+    const filePath = path.join(rulesDir, '00-ma-agents.md');
+    await fs.writeFile(filePath, '<!-- MA-AGENTS-START -->\nOLD CONTENT\n<!-- MA-AGENTS-END -->\n');
+
+    const agent = {
+      ...rooCode,
+      getProjectPath: () => path.join(projectRoot, '.roo', 'skills'),
+      instructionFiles: ['.roo/rules/00-ma-agents.md'],
+      injectionStrategy: { position: 'top', skipPatterns: ['---'] }
+    };
+
+    await updateAgentInstructions(agent, projectRoot);
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    assert.ok(!content.includes('OLD CONTENT'), 'old content should be replaced');
+    assert.ok(content.includes('MANIFEST.yaml'), 'should contain updated instruction');
+    // Verify only one set of markers
+    const startCount = (content.match(/<!-- MA-AGENTS-START -->/g) || []).length;
+    assert.strictEqual(startCount, 1, 'should have exactly one start marker');
+  });
+
+  await asyncTest('preserves user content when injecting into existing file', async () => {
+    const projectRoot = path.join(tmpDir, 'project-preserve');
+    await fs.ensureDir(projectRoot);
+
+    // Pre-create file with user content but no markers
+    const rulesDir = path.join(projectRoot, '.roo', 'rules');
+    await fs.ensureDir(rulesDir);
+    const filePath = path.join(rulesDir, '00-ma-agents.md');
+    await fs.writeFile(filePath, '# User Custom Rules\n\nAlways use TypeScript.\n');
+
+    const agent = {
+      ...rooCode,
+      getProjectPath: () => path.join(projectRoot, '.roo', 'skills'),
+      instructionFiles: ['.roo/rules/00-ma-agents.md'],
+      injectionStrategy: { position: 'top', skipPatterns: ['---'] }
+    };
+
+    await updateAgentInstructions(agent, projectRoot);
+
+    const content = await fs.readFile(filePath, 'utf-8');
+    assert.ok(content.includes('<!-- MA-AGENTS-START -->'), 'should contain markers');
+    assert.ok(content.includes('Always use TypeScript'), 'should preserve user content');
+  });
+
+  await asyncTest('file can be cleanly removed (uninstall scenario)', async () => {
+    const projectRoot = path.join(tmpDir, 'project-uninstall');
+    await fs.ensureDir(projectRoot);
+
+    const agent = {
+      ...rooCode,
+      getProjectPath: () => path.join(projectRoot, '.roo', 'skills'),
+      instructionFiles: ['.roo/rules/00-ma-agents.md'],
+      injectionStrategy: { position: 'top', skipPatterns: ['---'] }
+    };
+
+    // Install first
+    await updateAgentInstructions(agent, projectRoot);
+    const filePath = path.join(projectRoot, '.roo', 'rules', '00-ma-agents.md');
+    assert.ok(await fs.pathExists(filePath), 'file should exist after install');
+
+    // Simulate uninstall by removing the file
+    await fs.remove(filePath);
+    assert.ok(!(await fs.pathExists(filePath)), 'file should be removed after uninstall');
+  });
+
+  await cleanup();
+
+  // 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);
+})();