@eddacraft/anvil-adapters 0.1.0

package/src/__tests__/speckit-import-v2.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect } from 'vitest';
+import { readFile } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SpecKitImportAdapterV2 } from '../speckit/import-v2.js';
+import type { ExternalSpec } from '../common/types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, 'fixtures/speckit-official/auth-feature');
+
+describe('SpecKitImportAdapterV2 - Official Format', () => {
+  let adapter: SpecKitImportAdapterV2;
+
+  beforeEach(() => {
+    adapter = new SpecKitImportAdapterV2();
+  });
+
+  it('should have correct name and version', () => {
+    expect(adapter.name).toBe('speckit-import-v2');
+    expect(adapter.version).toBe('2.0.0');
+  });
+
+  it('should support spec-kit formats', () => {
+    expect(adapter.canImport('speckit')).toBe(true);
+    expect(adapter.canImport('spec-kit')).toBe(true);
+    expect(adapter.canImport('spec.md')).toBe(true);
+    expect(adapter.canImport('plan.md')).toBe(true);
+    expect(adapter.canImport('tasks.md')).toBe(true);
+    expect(adapter.canImport('unknown')).toBe(false);
+  });
+
+  it('should convert spec.md only to APS', async () => {
+    const specContent = await readFile(join(fixturesDir, 'spec.md'), 'utf-8');
+
+    const externalSpec: ExternalSpec = {
+      format: 'spec.md',
+      version: '2.0.0',
+      content: {
+        spec: { content: specContent },
+        metadata: {
+          timestamp: '2025-01-15T10:00:00Z',
+          author: 'test@example.com',
+        },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(true);
+    expect(result.data).toBeDefined();
+
+    if (result.success && result.data) {
+      // Check intent was built from user scenarios
+      expect(result.data.intent).toContain('User Authentication System');
+      expect(result.data.intent).toContain('new user wants to');
+
+      // Check metadata preservation
+      expect(result.data.metadata?.feature).toBe('User Authentication System');
+      expect(result.data.metadata?.userScenarios).toBeDefined();
+      expect(result.data.metadata?.requirements).toBeDefined();
+      expect(result.data.metadata?.successCriteria).toBeDefined();
+      expect(result.data.metadata?.clarifications).toBeDefined();
+
+      // Check proposed changes generated from scenarios
+      expect(result.data.proposed_changes.length).toBeGreaterThan(0);
+
+      // P1 and P2 scenarios should become changes
+      const p1Changes = result.data.proposed_changes.filter((c) => c.metadata?.priority === 'P1');
+      expect(p1Changes.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('should convert spec.md + plan.md to APS', async () => {
+    const specContent = await readFile(join(fixturesDir, 'spec.md'), 'utf-8');
+    const planContent = await readFile(join(fixturesDir, 'plan.md'), 'utf-8');
+
+    const externalSpec: ExternalSpec = {
+      format: 'speckit',
+      version: '2.0.0',
+      content: {
+        spec: { content: specContent },
+        plan: { content: planContent },
+        metadata: {
+          timestamp: '2025-01-15T10:00:00Z',
+          author: 'test@example.com',
+        },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(true);
+    expect(result.data).toBeDefined();
+
+    if (result.success && result.data) {
+      // Check technical context from plan.md
+      expect(result.data.metadata?.technicalContext).toBeDefined();
+      expect(result.data.metadata?.technicalContext?.language).toContain('TypeScript');
+      expect(result.data.metadata?.technicalContext?.dependencies).toBeDefined();
+      expect(result.data.metadata?.technicalContext?.dependencies?.length).toBeGreaterThan(0);
+
+      // Check constitution check
+      expect(result.data.metadata?.constitutionCheck).toBeDefined();
+
+      // Check project structure
+      expect(result.data.metadata?.projectStructure).toBeDefined();
+
+      // Check implementation details
+      expect(result.data.metadata?.implementationDetails).toBeDefined();
+
+      // Should have more changes with plan details
+      expect(result.data.proposed_changes.length).toBeGreaterThan(2);
+
+      // Should have dependency installation change
+      const depChange = result.data.proposed_changes.find((c) => c.type === 'dependency_add');
+      expect(depChange).toBeDefined();
+      expect(depChange?.description).toContain('dependencies');
+    }
+  });
+
+  it('should convert spec.md + plan.md + tasks.md to APS', async () => {
+    const specContent = await readFile(join(fixturesDir, 'spec.md'), 'utf-8');
+    const planContent = await readFile(join(fixturesDir, 'plan.md'), 'utf-8');
+    const tasksContent = await readFile(join(fixturesDir, 'tasks.md'), 'utf-8');
+
+    const externalSpec: ExternalSpec = {
+      format: 'speckit',
+      version: '2.0.0',
+      content: {
+        spec: { content: specContent },
+        plan: { content: planContent },
+        tasks: { content: tasksContent },
+        metadata: {
+          timestamp: '2025-01-15T10:00:00Z',
+          author: 'test@example.com',
+        },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(true);
+    expect(result.data).toBeDefined();
+
+    if (result.success && result.data) {
+      // Check phases from tasks.md
+      expect(result.data.metadata?.phases).toBeDefined();
+      expect(result.data.metadata?.phases?.length).toBeGreaterThan(0);
+
+      // Check task dependencies
+      expect(result.data.metadata?.taskDependencies).toBeDefined();
+
+      // Check implementation strategies
+      expect(result.data.metadata?.implementationStrategies).toBeDefined();
+
+      // Verify complete metadata
+      expect(result.data.metadata?.source_format).toBe('speckit-v2');
+    }
+  });
+
+  it('should handle missing spec.md', async () => {
+    const externalSpec: ExternalSpec = {
+      format: 'speckit',
+      version: '2.0.0',
+      content: {
+        plan: { content: '# Plan\nSome plan' },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(false);
+    expect(result.errors).toBeDefined();
+    expect(result.errors?.[0].code).toBe('MISSING_SPEC');
+  });
+
+  it('should preserve clarifications in metadata', async () => {
+    const specContent = await readFile(join(fixturesDir, 'spec.md'), 'utf-8');
+
+    const externalSpec: ExternalSpec = {
+      format: 'spec.md',
+      version: '2.0.0',
+      content: {
+        spec: { content: specContent },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(true);
+    if (result.success && result.data) {
+      expect(result.data.metadata?.clarifications).toBeDefined();
+      expect(Array.isArray(result.data.metadata?.clarifications)).toBe(true);
+      expect((result.data.metadata?.clarifications as string[]).length).toBeGreaterThan(0);
+    }
+  });
+
+  it('should map user scenarios to proposed changes', async () => {
+    const specContent = await readFile(join(fixturesDir, 'spec.md'), 'utf-8');
+
+    const externalSpec: ExternalSpec = {
+      format: 'spec.md',
+      version: '2.0.0',
+      content: {
+        spec: { content: specContent },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(true);
+    if (result.success && result.data) {
+      const changes = result.data.proposed_changes;
+
+      // Should have changes for user scenarios
+      const scenarioChanges = changes.filter((c) => c.metadata?.userStory);
+      expect(scenarioChanges.length).toBeGreaterThan(0);
+
+      // Check first scenario change
+      const firstChange = scenarioChanges[0];
+      expect(firstChange.metadata?.userStory?.asA).toBeDefined();
+      expect(firstChange.metadata?.userStory?.iWantTo).toBeDefined();
+      expect(firstChange.metadata?.userStory?.soThat).toBeDefined();
+      expect(firstChange.metadata?.acceptanceScenarios).toBeDefined();
+      expect(firstChange.metadata?.edgeCases).toBeDefined();
+    }
+  });
+
+  it('should preserve success criteria structure', async () => {
+    const specContent = await readFile(join(fixturesDir, 'spec.md'), 'utf-8');
+
+    const externalSpec: ExternalSpec = {
+      format: 'spec.md',
+      version: '2.0.0',
+      content: {
+        spec: { content: specContent },
+      },
+    };
+
+    const result = await adapter.convertToAPS(externalSpec);
+
+    expect(result.success).toBe(true);
+    if (result.success && result.data) {
+      const successCriteria = result.data.metadata?.successCriteria as Record<string, unknown>;
+      expect(successCriteria).toBeDefined();
+      expect(successCriteria.quantitative).toBeDefined();
+      expect(successCriteria.qualitative).toBeDefined();
+      expect(successCriteria.security).toBeDefined();
+      expect(Array.isArray(successCriteria.quantitative)).toBe(true);
+    }
+  });
+});

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

@@ -0,0 +1,209 @@
+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 { SpecKitImportAdapter } from '../speckit/import.js';
+import type { ExternalSpec, SpecContext } from '../common/types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, 'fixtures');
+
+describe('SpecKitImportAdapter', () => {
+  let adapter: SpecKitImportAdapter;
+
+  beforeEach(() => {
+    adapter = new SpecKitImportAdapter();
+  });
+
+  describe('basic properties', () => {
+    it('should have correct name and version', () => {
+      expect(adapter.name).toBe('speckit-import');
+      expect(adapter.version).toBe('1.0.0');
+    });
+
+    it('should support speckit and spec.md formats', () => {
+      expect(adapter.canImport('speckit')).toBe(true);
+      expect(adapter.canImport('spec.md')).toBe(true);
+      expect(adapter.canImport('unknown')).toBe(false);
+    });
+  });
+
+  describe('generateSpec', () => {
+    it('should generate a basic spec from intent', async () => {
+      const context: SpecContext = {
+        repositoryPath: '/test/repo',
+        branch: 'main',
+        author: 'test@example.com',
+      };
+
+      const result = await adapter.generateSpec('Test intent', context);
+
+      expect(result).toBeDefined();
+      expect(result.intent).toBe('Test intent');
+      expect(result.schema_version).toBe('0.1.0');
+      expect(result.proposed_changes).toHaveLength(1);
+      expect(result.proposed_changes[0].type).toBe('file_create');
+      expect(result.proposed_changes[0].path).toBe('spec.md');
+    });
+  });
+
+  describe('convertToAPS', () => {
+    it('should convert a valid spec.md to APS format', async () => {
+      const specContent = await readFile(join(fixturesDir, 'speckit/sample-spec.md'), 'utf-8');
+
+      const externalSpec: ExternalSpec = {
+        format: 'speckit',
+        version: '1.0.0',
+        content: {
+          specContent,
+          metadata: {
+            timestamp: '2024-01-15T10:00:00Z',
+            author: 'test@example.com',
+          },
+        },
+      };
+
+      const result = await adapter.convertToAPS(externalSpec);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+
+      if (result.success && result.data) {
+        console.log('Changes found:', result.data.proposed_changes.length);
+        console.log(
+          'Changes:',
+          result.data.proposed_changes.map((c) => ({
+            type: c.type,
+            path: c.path,
+            desc: c.description.substring(0, 50),
+          }))
+        );
+        expect(result.data.intent).toContain('JWT tokens');
+        expect(result.data.schema_version).toBe('0.1.0');
+        expect(result.data.proposed_changes.length).toBeGreaterThan(0);
+
+        // Check that goals and requirements are preserved in metadata
+        expect(result.data.metadata?.goals).toBeDefined();
+        expect(result.data.metadata?.requirements).toBeDefined();
+        expect(result.data.metadata?.source_format).toBe('speckit');
+
+        // Verify specific changes were parsed correctly
+        const fileCreateChanges = result.data.proposed_changes.filter(
+          (c) => c.type === 'file_create'
+        );
+        expect(fileCreateChanges.length).toBeGreaterThan(0);
+
+        const authControllerChange = fileCreateChanges.find(
+          (c) => c.path === 'src/controllers/auth.controller.ts'
+        );
+        expect(authControllerChange).toBeDefined();
+        expect(authControllerChange?.content).toContain('AuthController');
+      }
+    });
+
+    it('should handle missing spec content', async () => {
+      const externalSpec: ExternalSpec = {
+        format: 'speckit',
+        version: '1.0.0',
+        content: {
+          // Missing specContent
+        },
+      };
+
+      const result = await adapter.convertToAPS(externalSpec);
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors?.[0].code).toBe('MISSING_SPEC_CONTENT');
+    });
+
+    it('should handle spec without intent section', async () => {
+      const externalSpec: ExternalSpec = {
+        format: 'speckit',
+        version: '1.0.0',
+        content: {
+          specContent: '# Specification\n\n## Overview\n\nSome overview without intent.',
+        },
+      };
+
+      const result = await adapter.convertToAPS(externalSpec);
+
+      expect(result.success).toBe(true);
+      expect(result.warnings).toBeDefined();
+      // Should use overview as fallback for intent
+      expect(result.data?.intent).toContain('Some overview');
+    });
+
+    it('should reject unsupported formats', async () => {
+      const externalSpec: ExternalSpec = {
+        format: 'unknown-format',
+        version: '1.0.0',
+        content: {},
+      };
+
+      const result = await adapter.convertToAPS(externalSpec);
+
+      expect(result.success).toBe(false);
+      expect(result.errors?.[0].code).toBe('UNSUPPORTED_FORMAT');
+    });
+  });
+
+  describe('validateSpec', () => {
+    it('should validate a valid APS spec', async () => {
+      const spec = {
+        id: 'aps-12345678',
+        hash: '0'.repeat(64),
+        intent: 'This is a valid intent for testing',
+        schema_version: '0.1.0' as const,
+        proposed_changes: [
+          {
+            type: 'file_create' as const,
+            path: 'test.ts',
+            description: 'Create a test file',
+          },
+        ],
+        provenance: {
+          timestamp: new Date().toISOString(),
+          source: 'cli' as const,
+          version: '1.0.0',
+        },
+        validations: {
+          required_checks: [],
+          skip_checks: [],
+        },
+      };
+
+      const result = await adapter.validateSpec(spec);
+
+      expect(result.valid).toBe(true);
+      expect(result.issues).toBeUndefined();
+    });
+
+    it('should warn about empty changes', async () => {
+      const spec = {
+        id: 'aps-12345678',
+        hash: '0'.repeat(64),
+        intent: 'This is a valid intent for testing',
+        schema_version: '0.1.0' as const,
+        proposed_changes: [],
+        provenance: {
+          timestamp: new Date().toISOString(),
+          source: 'cli' as const,
+          version: '1.0.0',
+        },
+        validations: {
+          required_checks: [],
+          skip_checks: [],
+        },
+      };
+
+      const result = await adapter.validateSpec(spec);
+
+      expect(result.valid).toBe(true);
+      expect(result.issues).toBeDefined();
+      expect(result.issues?.[0].severity).toBe('warning');
+      expect(result.issues?.[0].message).toContain('No changes');
+    });
+  });
+});

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

@@ -0,0 +1,219 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SpecKitParser } from '../speckit/parser.js';
+
+describe('SpecKitParser', () => {
+  let parser: SpecKitParser;
+
+  beforeEach(() => {
+    parser = new SpecKitParser();
+  });
+
+  describe('parseSpecMarkdown', () => {
+    it('should parse intent section', () => {
+      const markdown = `# Specification
+      
+## Intent
+
+Build a REST API for user management with CRUD operations.
+
+## Other Section
+
+Some content`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.intent).toBe('Build a REST API for user management with CRUD operations.');
+    });
+
+    it('should parse overview section', () => {
+      const markdown = `# Spec
+
+## Overview
+
+This system provides comprehensive user management capabilities including create, read, update, and delete operations.
+
+## Details`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.overview).toContain('comprehensive user management');
+    });
+
+    it('should parse goals as list items', () => {
+      const markdown = `# Specification
+
+## Goals
+
+- Implement secure authentication
+- Support role-based access control
+- Provide RESTful API endpoints
+- Enable user profile management`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.goals).toBeDefined();
+      expect(result.goals).toHaveLength(4);
+      expect(result.goals?.[0]).toBe('Implement secure authentication');
+      expect(result.goals?.[3]).toBe('Enable user profile management');
+    });
+
+    it('should parse numbered list items', () => {
+      const markdown = `# Spec
+
+## Requirements
+
+1. Node.js version 18 or higher
+2. PostgreSQL database
+3. Redis for caching
+4. Docker for containerization`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.requirements).toBeDefined();
+      expect(result.requirements).toHaveLength(4);
+      expect(result.requirements?.[0]).toBe('Node.js version 18 or higher');
+    });
+
+    it('should handle multi-line list items', () => {
+      const markdown = `# Spec
+
+## Goals
+
+- Implement authentication system
+  with JWT tokens and refresh mechanism
+- Support multiple authentication providers
+  including OAuth2 and SAML`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.goals).toHaveLength(2);
+      expect(result.goals?.[0]).toBe(
+        'Implement authentication system with JWT tokens and refresh mechanism'
+      );
+    });
+
+    it('should parse changes section with subsections', () => {
+      const markdown = `# Specification
+
+## Changes
+
+### Create authentication controller
+
+Create a new controller at \`src/auth.controller.ts\`
+
+\`\`\`typescript
+export class AuthController {
+  // Implementation
+}
+\`\`\`
+
+### Update main application
+
+Modify \`src/app.ts\` to include auth routes`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.changes).toBeDefined();
+      expect(result.changes).toHaveLength(2);
+
+      const createChange = result.changes?.[0];
+      expect(createChange?.type).toBe('file_create');
+      expect(createChange?.description).toContain('Create authentication controller');
+      expect(createChange?.path).toBe('src/auth.controller.ts');
+      expect(createChange?.content).toContain('export class AuthController');
+
+      const updateChange = result.changes?.[1];
+      expect(updateChange?.type).toBe('file_update');
+      expect(updateChange?.path).toBe('src/app.ts');
+    });
+
+    it('should parse changes from list items', () => {
+      const markdown = `# Specification
+
+## Changes
+
+- Create new file \`config/database.ts\` for database configuration
+- Update \`package.json\` to add PostgreSQL dependency
+- Delete obsolete \`src/old-db.ts\` file
+- Install new dependency: express-validator
+- Run migration script to update database schema`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.changes).toHaveLength(5);
+
+      expect(result.changes?.[0].type).toBe('file_create');
+      expect(result.changes?.[0].path).toBe('config/database.ts');
+
+      expect(result.changes?.[1].type).toBe('file_update');
+      expect(result.changes?.[1].path).toBe('package.json');
+
+      expect(result.changes?.[2].type).toBe('file_delete');
+      expect(result.changes?.[2].path).toBe('src/old-db.ts');
+
+      expect(result.changes?.[3].type).toBe('dependency_add');
+
+      expect(result.changes?.[4].type).toBe('script_execute');
+    });
+
+    it('should handle empty sections gracefully', () => {
+      const markdown = `# Specification
+
+## Intent
+
+## Goals
+
+## Requirements`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.intent).toBe('');
+      expect(result.goals).toEqual([]);
+      expect(result.requirements).toEqual([]);
+    });
+
+    it('should handle alternative section names', () => {
+      const markdown = `# Specification
+
+## Purpose
+
+Implement user authentication
+
+## Objectives
+
+- Secure the application
+- Manage user sessions
+
+## Prerequisites
+
+- Database setup
+- SSL certificates`;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.intent).toBe('Implement user authentication');
+      expect(result.goals).toContain('Secure the application');
+      expect(result.requirements).toContain('Database setup');
+    });
+
+    it('should extract code blocks with correct language', () => {
+      const markdown = `# Spec
+
+## Changes
+
+### Update TypeScript config
+
+\`\`\`json
+{
+  "compilerOptions": {
+    "strict": true
+  }
+}
+\`\`\``;
+
+      const result = parser.parseSpecMarkdown(markdown);
+
+      expect(result.changes?.[0].content).toContain('"strict": true');
+    });
+  });
+});