test(devin-adapter): add comprehensive tests for Devin Desktop adapter

Add test coverage for the Devin Desktop adapter including:
- Command reference transformation from colon to hyphen syntax
- YAML frontmatter escaping for special characters and implicit scalars
- File path generation for workflows
- Integration with available tools detection
- Init and update command workflows

Author: mehdishahdoost

src/core/command-generation/adapters/devin.ts

@@ -6,6 +6,7 @@
  */
 
 import path from 'path';
+import { transformToHyphenCommands } from '../../../utils/command-references.js';
 import type { CommandContent, ToolCommandAdapter } from '../types.js';
 
 /**
@@ -41,6 +42,8 @@ function formatTagsArray(tags: string[]): string {
  * Devin Desktop adapter for command generation.
  * File path: .devin/workflows/opsx-<id>.md
  * Frontmatter: name, description, category, tags
+ * 
+ * Devin Desktop uses slash-hyphen syntax (/opsx-apply) instead of colon syntax (/opsx:apply).
  */
 export const devinAdapter: ToolCommandAdapter = {
   toolId: 'devin',
@@ -50,14 +53,17 @@ export const devinAdapter: ToolCommandAdapter = {
   },
 
   formatFile(content: CommandContent): string {
+    // Transform command references from colon to hyphen syntax
+    const transformedBody = transformToHyphenCommands(content.body);
+    
     return `---
 name: ${escapeYamlValue(content.name)}
 description: ${escapeYamlValue(content.description)}
 category: ${escapeYamlValue(content.category)}
 tags: ${formatTagsArray(content.tags)}
 ---
 
-${content.body}
+${transformedBody}
 `;
   },
 };

test/core/available-tools.test.ts

@@ -46,6 +46,19 @@ describe('available-tools', () => {
       expect(tools).toHaveLength(3);
     });
 
+    it('should detect Devin Desktop when .devin directory exists', async () => {
+      await fs.mkdir(path.join(testDir, '.devin'), { recursive: true });
+
+      const tools = getAvailableTools(testDir);
+      const toolValues = tools.map((t) => t.value);
+      expect(toolValues).toContain('devin');
+      
+      const devinTool = tools.find((t) => t.value === 'devin');
+      expect(devinTool).toBeDefined();
+      expect(devinTool?.name).toBe('Devin Desktop');
+      expect(devinTool?.skillsDir).toBe('.devin');
+    });
+
     it('should ignore files that are not directories', async () => {
       // Create a file named .claude instead of a directory
       await fs.writeFile(path.join(testDir, '.claude'), 'not a directory');

test/core/command-generation/adapters.test.ts

@@ -13,6 +13,7 @@ import { continueAdapter } from '../../../src/core/command-generation/adapters/c
 import { costrictAdapter } from '../../../src/core/command-generation/adapters/costrict.js';
 import { crushAdapter } from '../../../src/core/command-generation/adapters/crush.js';
 import { cursorAdapter } from '../../../src/core/command-generation/adapters/cursor.js';
+import { devinAdapter } from '../../../src/core/command-generation/adapters/devin.js';
 import { factoryAdapter } from '../../../src/core/command-generation/adapters/factory.js';
 import { geminiAdapter } from '../../../src/core/command-generation/adapters/gemini.js';
 import { githubCopilotAdapter } from '../../../src/core/command-generation/adapters/github-copilot.js';
@@ -126,6 +127,76 @@ describe('command-generation/adapters', () => {
     });
   });
 
+  describe('devinAdapter', () => {
+    it('should have correct toolId', () => {
+      expect(devinAdapter.toolId).toBe('devin');
+    });
+
+    it('should generate correct file path', () => {
+      const filePath = devinAdapter.getFilePath('explore');
+      expect(filePath).toBe(path.join('.devin', 'workflows', 'opsx-explore.md'));
+    });
+
+    it('should generate correct file paths for different commands', () => {
+      expect(devinAdapter.getFilePath('new')).toBe(path.join('.devin', 'workflows', 'opsx-new.md'));
+      expect(devinAdapter.getFilePath('bulk-archive')).toBe(path.join('.devin', 'workflows', 'opsx-bulk-archive.md'));
+    });
+
+    it('should format file with YAML frontmatter', () => {
+      const output = devinAdapter.formatFile(sampleContent);
+
+      expect(output).toContain('---\n');
+      expect(output).toContain('name: OpenSpec Explore');
+      expect(output).toContain('description: Enter explore mode for thinking');
+      expect(output).toContain('category: Workflow');
+      expect(output).toContain('tags: [workflow, explore, experimental]');
+      expect(output).toContain('---\n\n');
+      expect(output).toContain('This is the command body.');
+    });
+
+    it('should transform colon command references to hyphen format', () => {
+      const contentWithRefs: CommandContent = {
+        ...sampleContent,
+        body: 'Run /opsx:apply to implement. Then use /opsx:verify.',
+      };
+      const output = devinAdapter.formatFile(contentWithRefs);
+      expect(output).toContain('/opsx-apply');
+      expect(output).toContain('/opsx-verify');
+      expect(output).not.toContain('/opsx:apply');
+      expect(output).not.toContain('/opsx:verify');
+    });
+
+    it('should escape YAML special characters in frontmatter', () => {
+      const contentWithSpecialChars: CommandContent = {
+        ...sampleContent,
+        name: 'Test: Command',
+        description: 'Fix "auth" feature',
+      };
+      const output = devinAdapter.formatFile(contentWithSpecialChars);
+      expect(output).toContain('name: "Test: Command"');
+      expect(output).toContain('description: "Fix \\"auth\\" feature"');
+    });
+
+    it('should escape implicit YAML scalars in frontmatter', () => {
+      const contentWithImplicitScalar: CommandContent = {
+        ...sampleContent,
+        name: 'true',
+        description: 'null',
+        category: 'on',
+      };
+      const output = devinAdapter.formatFile(contentWithImplicitScalar);
+      expect(output).toContain('name: "true"');
+      expect(output).toContain('description: "null"');
+      expect(output).toContain('category: "on"');
+    });
+
+    it('should handle empty tags', () => {
+      const contentNoTags: CommandContent = { ...sampleContent, tags: [] };
+      const output = devinAdapter.formatFile(contentNoTags);
+      expect(output).toContain('tags: []');
+    });
+  });
+
   describe('amazonQAdapter', () => {
     it('should have correct toolId', () => {
       expect(amazonQAdapter.toolId).toBe('amazon-q');

test/core/command-generation/registry.test.ts

@@ -21,6 +21,12 @@ describe('command-generation/registry', () => {
       expect(adapter?.toolId).toBe('windsurf');
     });
 
+    it('should return Devin adapter for "devin"', () => {
+      const adapter = CommandAdapterRegistry.get('devin');
+      expect(adapter).toBeDefined();
+      expect(adapter?.toolId).toBe('devin');
+    });
+
     it('should return Junie adapter for "junie"', () => {
       const adapter = CommandAdapterRegistry.get('junie');
       expect(adapter).toBeDefined();
@@ -45,13 +51,14 @@ describe('command-generation/registry', () => {
       expect(adapters.length).toBeGreaterThanOrEqual(3); // At least Claude, Cursor, Windsurf
     });
 
-    it('should include Claude, Cursor, and Windsurf adapters', () => {
+    it('should include Claude, Cursor, Windsurf, and Devin adapters', () => {
       const adapters = CommandAdapterRegistry.getAll();
       const toolIds = adapters.map((a) => a.toolId);
 
       expect(toolIds).toContain('claude');
       expect(toolIds).toContain('cursor');
       expect(toolIds).toContain('windsurf');
+      expect(toolIds).toContain('devin');
     });
   });
 
@@ -60,6 +67,7 @@ describe('command-generation/registry', () => {
       expect(CommandAdapterRegistry.has('claude')).toBe(true);
       expect(CommandAdapterRegistry.has('cursor')).toBe(true);
       expect(CommandAdapterRegistry.has('windsurf')).toBe(true);
+      expect(CommandAdapterRegistry.has('devin')).toBe(true);
       expect(CommandAdapterRegistry.has('junie')).toBe(true);
     });
 
@@ -74,10 +82,12 @@ describe('command-generation/registry', () => {
       const claudeAdapter = CommandAdapterRegistry.get('claude');
       const cursorAdapter = CommandAdapterRegistry.get('cursor');
       const windsurfAdapter = CommandAdapterRegistry.get('windsurf');
+      const devinAdapter = CommandAdapterRegistry.get('devin');
 
       expect(claudeAdapter?.getFilePath('test')).toContain('.claude');
       expect(cursorAdapter?.getFilePath('test')).toContain('.cursor');
       expect(windsurfAdapter?.getFilePath('test')).toContain('.windsurf');
+      expect(devinAdapter?.getFilePath('test')).toContain('.devin');
     });
 
     it('registered adapters should have working formatFile', () => {

test/core/init.test.ts

@@ -457,6 +457,21 @@ describe('InitCommand', () => {
       expect(await fileExists(cmdFile)).toBe(true);
     });
 
+    it('should generate Devin Desktop workflows', async () => {
+      const initCommand = new InitCommand({ tools: 'devin', force: true });
+      await initCommand.execute(testDir);
+
+      const cmdFile = path.join(testDir, '.devin', 'workflows', 'opsx-explore.md');
+      expect(await fileExists(cmdFile)).toBe(true);
+
+      const content = await fs.readFile(cmdFile, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      // Verify command references are transformed to hyphen syntax
+      expect(content).not.toContain('/opsx:');
+    });
+
     it('should generate Continue prompt files', async () => {
       const initCommand = new InitCommand({ tools: 'continue', force: true });
       await initCommand.execute(testDir);

test/core/update.test.ts

@@ -251,6 +251,33 @@ Old instructions content
       }
     });
 
+    it('should update Devin Desktop workflows with hyphen command references', async () => {
+      // Set up Devin Desktop directory with a skill to indicate it's configured
+      const skillsDir = path.join(testDir, '.devin', 'skills');
+      await fs.mkdir(path.join(skillsDir, 'openspec-explore'), {
+        recursive: true,
+      });
+      await fs.writeFile(
+        path.join(skillsDir, 'openspec-explore', 'SKILL.md'),
+        'old content'
+      );
+
+      await updateCommand.execute(testDir);
+
+      // Verify workflows were created
+      const workflowsDir = path.join(testDir, '.devin', 'workflows');
+      const exploreWorkflow = path.join(workflowsDir, 'opsx-explore.md');
+      const exists = await FileSystemUtils.fileExists(exploreWorkflow);
+      expect(exists).toBe(true);
+
+      const content = await fs.readFile(exploreWorkflow, 'utf-8');
+      expect(content).toContain('---');
+      expect(content).toContain('name:');
+      expect(content).toContain('description:');
+      // Verify command references are transformed to hyphen syntax
+      expect(content).not.toContain('/opsx:');
+    });
+
   });
 
   describe('multi-tool support', () => {