@eddacraft/anvil-adapters 0.1.0

package/src/__tests__/generic-format-adapter.test.ts

@@ -0,0 +1,398 @@
+/**
+ * Generic Format Adapter Tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { GenericMarkdownAdapter } from '../generic/format-adapter.js';
+import type { ParseContext } from '../base/types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, 'fixtures/generic');
+
+describe('GenericMarkdownAdapter', () => {
+  let adapter: GenericMarkdownAdapter;
+
+  beforeEach(() => {
+    adapter = new GenericMarkdownAdapter();
+  });
+
+  describe('metadata', () => {
+    it('should have correct name and version', () => {
+      expect(adapter.metadata.name).toBe('generic-markdown');
+      expect(adapter.metadata.version).toBe('1.0.0');
+    });
+
+    it('should have correct display name', () => {
+      expect(adapter.metadata.displayName).toBe('Generic Markdown');
+    });
+
+    it('should support generic formats', () => {
+      expect(adapter.metadata.formats).toContain('generic');
+      expect(adapter.metadata.formats).toContain('prd');
+      expect(adapter.metadata.formats).toContain('plan');
+      expect(adapter.metadata.formats).toContain('todo');
+    });
+
+    it('should support markdown extensions', () => {
+      expect(adapter.metadata.extensions).toContain('.md');
+      expect(adapter.metadata.extensions).toContain('.markdown');
+    });
+  });
+
+  describe('canImport / canExport', () => {
+    it('should support importing generic formats', () => {
+      expect(adapter.canImport('generic')).toBe(true);
+      expect(adapter.canImport('prd')).toBe(true);
+      expect(adapter.canImport('plan')).toBe(true);
+      expect(adapter.canImport('todo')).toBe(true);
+    });
+
+    it('should support exporting to generic format', () => {
+      expect(adapter.canExport('generic')).toBe(true);
+      expect(adapter.canExport('markdown')).toBe(true);
+    });
+
+    it('should support markdown extensions', () => {
+      expect(adapter.canImport('.md')).toBe(true);
+      expect(adapter.canImport('.markdown')).toBe(true);
+    });
+  });
+
+  describe('detect', () => {
+    it('should detect simple PRD with moderate confidence', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = adapter.detect(content);
+
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBeGreaterThanOrEqual(30);
+      expect(result.confidence).toBeLessThanOrEqual(45); // Capped for fallback
+      expect(result.reason).toContain('markdown-headings');
+    });
+
+    it('should detect TODO list', async () => {
+      const content = await readFile(join(fixturesDir, 'todo-list.md'), 'utf-8');
+      const result = adapter.detect(content);
+
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBeGreaterThanOrEqual(30);
+    });
+
+    it('should detect detailed plan', async () => {
+      const content = await readFile(join(fixturesDir, 'plan-detailed.md'), 'utf-8');
+      const result = adapter.detect(content);
+
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBeGreaterThanOrEqual(30);
+      expect(result.reason).toContain('requirements-section');
+    });
+
+    it('should detect RFC document', async () => {
+      const content = await readFile(join(fixturesDir, 'rfc-example.md'), 'utf-8');
+      const result = adapter.detect(content);
+
+      expect(result.detected).toBe(true);
+      expect(result.confidence).toBeGreaterThanOrEqual(30);
+    });
+
+    it('should have lower confidence than specific formats', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = adapter.detect(content);
+
+      // Generic adapter confidence should be capped at 45%
+      // so BMAD (50%+) and SpecKit (50%+) win
+      expect(result.confidence).toBeLessThanOrEqual(45);
+    });
+
+    it('should not detect very short content', () => {
+      const content = '# Title\n\nShort content.';
+      const result = adapter.detect(content);
+
+      expect(result.detected).toBe(false);
+    });
+  });
+
+  describe('parse', () => {
+    it('should parse simple PRD', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = await adapter.parse(content);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data?.schema_version).toBe('0.1.0');
+        expect(result.data?.intent).toBeDefined();
+        expect(result.data?.proposed_changes).toBeDefined();
+        expect(result.data?.hash).toBeDefined();
+      }
+    });
+
+    it('should extract requirements as changes', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = await adapter.parse(content);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data?.proposed_changes.length).toBeGreaterThan(0);
+        // Should have changes from requirements
+        const hasRequirements = result.data?.proposed_changes.some((c) =>
+          c.description.toLowerCase().includes('metric')
+        );
+        expect(hasRequirements).toBe(true);
+      }
+    });
+
+    it('should extract tasks as changes', async () => {
+      const content = await readFile(join(fixturesDir, 'todo-list.md'), 'utf-8');
+      const result = await adapter.parse(content);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data?.proposed_changes.length).toBeGreaterThan(0);
+        // Should have tasks
+        const hasTasks = result.data?.proposed_changes.some((c) =>
+          c.description.toLowerCase().includes('pipeline')
+        );
+        expect(hasTasks).toBe(true);
+      }
+    });
+
+    it('should extract features as changes', async () => {
+      const content = await readFile(join(fixturesDir, 'todo-list.md'), 'utf-8');
+      const result = await adapter.parse(content);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        // Should have features
+        const hasFeatures = result.data?.proposed_changes.some((c) =>
+          c.description.toLowerCase().includes('oauth')
+        );
+        expect(hasFeatures).toBe(true);
+      }
+    });
+
+    it('should include goals in metadata', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = await adapter.parse(content);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data?.metadata?.goals).toBeDefined();
+        expect(Array.isArray(result.data?.metadata?.goals)).toBe(true);
+      }
+    });
+
+    it('should use context for provenance', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const context: ParseContext = {
+        filePath: '/path/to/prd.md',
+        author: 'Test Author',
+        repositoryPath: '/path/to/repo',
+      };
+
+      const result = await adapter.parse(content, context);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data?.provenance.author).toBe('Test Author');
+        expect(result.data?.provenance.repository).toBe('/path/to/repo');
+      }
+    });
+
+    it('should handle documents with only goals', () => {
+      const content = `# Project Goals
+
+## Goals
+
+- Improve performance
+- Reduce costs
+- Enhance security`;
+
+      return adapter.parse(content).then((result) => {
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.data?.metadata?.goals).toBeDefined();
+        }
+      });
+    });
+
+    it('should extract intent from purpose section', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = await adapter.parse(content);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data?.intent).toContain('dashboard');
+      }
+    });
+  });
+
+  describe('serialize', () => {
+    it('should serialize plan to generic markdown', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const parseResult = await adapter.parse(content);
+
+      expect(parseResult.success).toBe(true);
+      if (!parseResult.success) return;
+
+      const serializeResult = await adapter.serialize(parseResult.data!);
+
+      expect(serializeResult.success).toBe(true);
+      if (serializeResult.success) {
+        expect(serializeResult.content).toContain('# ');
+        expect(serializeResult.content).toContain('## ');
+      }
+    });
+
+    it('should include changes section', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const parseResult = await adapter.parse(content);
+
+      expect(parseResult.success).toBe(true);
+      if (!parseResult.success) return;
+
+      const serializeResult = await adapter.serialize(parseResult.data!);
+
+      expect(serializeResult.success).toBe(true);
+      if (serializeResult.success) {
+        expect(serializeResult.content).toContain('## Changes');
+      }
+    });
+
+    it('should include metadata section', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const parseResult = await adapter.parse(content);
+
+      expect(parseResult.success).toBe(true);
+      if (!parseResult.success) return;
+
+      const serializeResult = await adapter.serialize(parseResult.data!);
+
+      expect(serializeResult.success).toBe(true);
+      if (serializeResult.success) {
+        expect(serializeResult.content).toContain('## Metadata');
+        expect(serializeResult.content).toContain('Author');
+      }
+    });
+
+    it('should maintain roundtrip fidelity', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const parse1 = await adapter.parse(content);
+
+      expect(parse1.success).toBe(true);
+      if (!parse1.success) return;
+
+      const serialize = await adapter.serialize(parse1.data!);
+
+      expect(serialize.success).toBe(true);
+      if (!serialize.success) return;
+
+      const parse2 = await adapter.parse(serialize.content);
+
+      expect(parse2.success).toBe(true);
+      if (!parse2.success) return;
+
+      // Serialized format uses list items under "Files to Create/Update"
+      // which won't be detected as requirements/tasks by the parser
+      // Check that document has valid structure
+      expect(parse2.data?.intent).toBeDefined();
+      expect(parse2.data?.provenance.author).toBeDefined();
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate simple PRD', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+      const result = await adapter.validate(content);
+
+      expect(result.valid).toBe(true);
+      expect(result.summary).toContain('valid');
+    });
+
+    it('should reject very short content', async () => {
+      const content = '# Short';
+      const result = await adapter.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.issues).toBeDefined();
+      if (result.issues) {
+        expect(result.issues.some((i) => i.code === 'CONTENT_TOO_SHORT')).toBe(true);
+      }
+    });
+
+    it('should warn about missing planning sections', async () => {
+      const content = `# Random Document
+
+This is just random content without any planning sections like requirements,
+tasks, or features. It should still be valid but with warnings.
+
+## Introduction
+
+Some introduction text here.
+
+## Conclusion
+
+Some conclusion text here.`;
+
+      const result = await adapter.validate(content);
+
+      expect(result.issues).toBeDefined();
+      if (result.issues) {
+        expect(result.issues.some((i) => i.code === 'NO_PLANNING_SECTIONS')).toBe(true);
+      }
+    });
+
+    it('should validate detailed plan', async () => {
+      const content = await readFile(join(fixturesDir, 'plan-detailed.md'), 'utf-8');
+      const result = await adapter.validate(content);
+
+      expect(result.valid).toBe(true);
+    });
+
+    it('should validate RFC document', async () => {
+      const content = await readFile(join(fixturesDir, 'rfc-example.md'), 'utf-8');
+      const result = await adapter.validate(content);
+
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe('integration', () => {
+    it('should complete full workflow: detect → parse → validate → serialize', async () => {
+      const content = await readFile(join(fixturesDir, 'prd-simple.md'), 'utf-8');
+
+      // Detect
+      const detectResult = adapter.detect(content);
+      expect(detectResult.detected).toBe(true);
+
+      // Parse
+      const parseResult = await adapter.parse(content);
+      expect(parseResult.success).toBe(true);
+      if (!parseResult.success) return;
+
+      // Validate
+      const validateResult = await adapter.validate(content);
+      expect(validateResult.valid).toBe(true);
+
+      // Serialize
+      const serializeResult = await adapter.serialize(parseResult.data!);
+      expect(serializeResult.success).toBe(true);
+    });
+
+    it('should handle multiple document types', async () => {
+      const files = ['prd-simple.md', 'todo-list.md', 'plan-detailed.md', 'rfc-example.md'];
+
+      for (const file of files) {
+        const content = await readFile(join(fixturesDir, file), 'utf-8');
+
+        const detectResult = adapter.detect(content);
+        expect(detectResult.detected).toBe(true);
+
+        const parseResult = await adapter.parse(content);
+        expect(parseResult.success).toBe(true);
+      }
+    });
+  });
+});

package/src/__tests__/speckit-export.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SpecKitExportAdapter } from '../speckit/export.js';
+import type { APSPlan } from '@eddacraft/anvil-core';
+
+interface SpecKitContent {
+  specContent: string;
+  planContent: string;
+  tasksContent: string;
+}
+
+describe('SpecKitExportAdapter', () => {
+  let adapter: SpecKitExportAdapter;
+  let sampleAPSPlan: APSPlan;
+
+  beforeEach(() => {
+    adapter = new SpecKitExportAdapter();
+
+    sampleAPSPlan = {
+      id: 'aps-12345678',
+      hash: '0'.repeat(64),
+      intent: 'Implement a user authentication system with JWT tokens to secure API endpoints',
+      schema_version: '0.1.0',
+      proposed_changes: [
+        {
+          type: 'file_create',
+          path: 'src/auth/controller.ts',
+          description: 'Create authentication controller',
+          content: 'export class AuthController { /* ... */ }',
+        },
+        {
+          type: 'file_update',
+          path: 'src/app.ts',
+          description: 'Update main app to include auth routes',
+        },
+        {
+          type: 'dependency_add',
+          path: 'package.json',
+          description: 'Add jsonwebtoken dependency',
+        },
+      ],
+      provenance: {
+        timestamp: '2024-01-15T10:00:00Z',
+        source: 'cli',
+        version: '1.0.0',
+        author: 'test@example.com',
+      },
+      validations: {
+        required_checks: ['lint', 'test'],
+        skip_checks: [],
+      },
+      metadata: {
+        goals: ['Secure API endpoints', 'Implement JWT authentication'],
+        requirements: ['Node.js 18+', 'Express.js'],
+        overview: 'JWT-based authentication system',
+      },
+    };
+  });
+
+  describe('basic properties', () => {
+    it('should have correct name and version', () => {
+      expect(adapter.name).toBe('speckit-export');
+      expect(adapter.version).toBe('1.0.0');
+    });
+
+    it('should support speckit export formats', () => {
+      expect(adapter.canExport('speckit')).toBe(true);
+      expect(adapter.canExport('spec.md')).toBe(true);
+      expect(adapter.canExport('unknown')).toBe(false);
+    });
+  });
+
+  describe('convertFromAPS', () => {
+    it('should convert APS to SpecKit format', async () => {
+      const result = await adapter.convertFromAPS(sampleAPSPlan);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+
+      if (result.success && result.data) {
+        expect(result.data.format).toBe('speckit');
+        expect(result.data.version).toBe('1.0.0');
+
+        const content = result.data.content as SpecKitContent;
+        expect(content.specContent).toBeDefined();
+        expect(content.planContent).toBeDefined();
+        expect(content.tasksContent).toBeDefined();
+
+        // Check spec content includes intent
+        expect(content.specContent).toContain('## Intent');
+        expect(content.specContent).toContain(sampleAPSPlan.intent);
+
+        // Check goals and requirements are included
+        expect(content.specContent).toContain('## Goals');
+        expect(content.specContent).toContain('Secure API endpoints');
+
+        // Check changes are properly formatted
+        expect(content.specContent).toContain('## Changes');
+        expect(content.specContent).toContain('### Files to Create');
+        expect(content.specContent).toContain('src/auth/controller.ts');
+      }
+    });
+
+    it('should generate valid markdown for spec.md', async () => {
+      const result = await adapter.convertFromAPS(sampleAPSPlan);
+
+      expect(result.success).toBe(true);
+      const content = result.data?.content as SpecKitContent;
+      const specMarkdown = content.specContent;
+
+      // Check markdown structure
+      expect(specMarkdown).toMatch(/^# Specification/);
+      expect(specMarkdown).toContain('## Intent');
+      expect(specMarkdown).toContain('## Goals');
+      expect(specMarkdown).toContain('## Requirements');
+      expect(specMarkdown).toContain('## Changes');
+
+      // Check code blocks are properly formatted
+      expect(specMarkdown).toMatch(/```\w+\n[\s\S]*?```/);
+    });
+
+    it('should generate valid plan.md', async () => {
+      const result = await adapter.convertFromAPS(sampleAPSPlan);
+
+      expect(result.success).toBe(true);
+      const content = result.data?.content as SpecKitContent;
+      const planMarkdown = content.planContent;
+
+      // Check plan structure
+      expect(planMarkdown).toContain('# Implementation Plan');
+      expect(planMarkdown).toContain(`Generated from APS: ${sampleAPSPlan.id}`);
+      expect(planMarkdown).toContain('## Summary');
+      expect(planMarkdown).toContain('## Implementation Steps');
+
+      // Check steps are numbered
+      expect(planMarkdown).toMatch(/1\. \*\*.+\*\*/);
+      expect(planMarkdown).toMatch(/2\. \*\*.+\*\*/);
+    });
+
+    it('should generate valid tasks.md', async () => {
+      const result = await adapter.convertFromAPS(sampleAPSPlan);
+
+      expect(result.success).toBe(true);
+      const content = result.data?.content as SpecKitContent;
+      const tasksMarkdown = content.tasksContent;
+
+      // Check tasks structure
+      expect(tasksMarkdown).toContain('# Tasks');
+      expect(tasksMarkdown).toContain(`Generated from APS: ${sampleAPSPlan.id}`);
+      expect(tasksMarkdown).toContain('## Task List');
+      expect(tasksMarkdown).toContain('## Progress');
+
+      // Check task formatting
+      expect(tasksMarkdown).toMatch(/- \[ \] ⏳ .+/);
+
+      // Check progress calculation
+      expect(tasksMarkdown).toContain('Total tasks:');
+      expect(tasksMarkdown).toContain('Progress: 0%');
+    });
+
+    it('should handle APS with execution history', async () => {
+      const planWithExecutions: APSPlan = {
+        ...sampleAPSPlan,
+        executions: [
+          {
+            operation: 'apply' as const,
+            timestamp: '2024-01-16T12:00:00Z',
+            status: 'success',
+            executed_by: 'ci-bot',
+            changes_applied: ['change-1', 'change-2'],
+          },
+          {
+            operation: 'apply' as const,
+            timestamp: '2024-01-16T13:00:00Z',
+            status: 'failed',
+            executed_by: 'developer@example.com',
+            logs: ['Error: Build failed'],
+          },
+        ],
+      };
+
+      const result = await adapter.convertFromAPS(planWithExecutions);
+
+      expect(result.success).toBe(true);
+      const content = result.data?.content as SpecKitContent;
+      const tasksMarkdown = content.tasksContent;
+
+      expect(tasksMarkdown).toContain('## Execution History');
+      expect(tasksMarkdown).toContain('Status: success');
+      expect(tasksMarkdown).toContain('Status: failed');
+      expect(tasksMarkdown).toContain('Error: Build failed');
+    });
+
+    it('should preserve metadata in export', async () => {
+      const result = await adapter.convertFromAPS(sampleAPSPlan);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata).toBeDefined();
+      expect(result.data?.metadata?.aps_id).toBe(sampleAPSPlan.id);
+      expect(result.data?.metadata?.aps_hash).toBe(sampleAPSPlan.hash);
+      expect(result.data?.metadata?.generator).toBe('speckit-export');
+    });
+  });
+
+  describe('validateSpec', () => {
+    it('should validate specs before export', async () => {
+      const invalidSpec: APSPlan = {
+        ...sampleAPSPlan,
+        intent: 'Short', // Too short
+      };
+
+      const result = await adapter.validateSpec(invalidSpec);
+
+      expect(result.valid).toBe(false);
+      expect(result.issues).toBeDefined();
+      expect(result.issues?.[0].path).toBe('intent');
+      expect(result.issues?.[0].severity).toBe('error');
+    });
+
+    it('should warn about empty changes', async () => {
+      const emptySpec: APSPlan = {
+        ...sampleAPSPlan,
+        proposed_changes: [],
+      };
+
+      const result = await adapter.validateSpec(emptySpec);
+
+      expect(result.valid).toBe(true);
+      expect(result.issues).toBeDefined();
+      expect(result.issues?.[0].severity).toBe('warning');
+      expect(result.issues?.[0].message).toContain('No changes');
+    });
+  });
+});