@mytechtoday/augment-extensions 1.2.2 → 1.3.0

package/augment-extensions/workflows/adr-support/__tests__/adr-validator.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Tests for ADR Validation Module
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import {
+  ADR,
+  isValidISO8601,
+  validateMetadata,
+  validateOptionalFields,
+  validateADRReferences
+} from '../adr-validator';
+
+describe('ADR Validator', () => {
+  describe('isValidISO8601', () => {
+    it('should accept valid ISO 8601 dates', () => {
+      expect(isValidISO8601('2026-02-06')).toBe(true);
+      expect(isValidISO8601('2024-01-01')).toBe(true);
+      expect(isValidISO8601('2024-12-31')).toBe(true);
+    });
+
+    it('should reject invalid dates', () => {
+      expect(isValidISO8601('2024-02-30')).toBe(false); // Invalid day
+      expect(isValidISO8601('2024-13-01')).toBe(false); // Invalid month
+      expect(isValidISO8601('2024-00-01')).toBe(false); // Invalid month
+      expect(isValidISO8601('2024-01-32')).toBe(false); // Invalid day
+      expect(isValidISO8601('24-01-01')).toBe(false);   // Wrong format
+      expect(isValidISO8601('2024/01/01')).toBe(false); // Wrong separator
+      expect(isValidISO8601('2024-1-1')).toBe(false);   // Missing leading zeros
+      expect(isValidISO8601('not-a-date')).toBe(false);
+      expect(isValidISO8601('')).toBe(false);
+    });
+  });
+
+  describe('validateMetadata', () => {
+    it('should accept valid ADR metadata', () => {
+      const validADR: ADR = {
+        id: 'adr-0001',
+        title: 'Use PostgreSQL for Primary Database',
+        status: 'approved',
+        date: '2026-02-06',
+        deciders: ['Tech Lead', 'Database Architect']
+      };
+
+      const result = validateMetadata(validADR);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+
+    it('should reject missing required fields', () => {
+      const invalidADR = {
+        id: 'adr-0001',
+        title: 'Test',
+        status: 'approved'
+      } as ADR;
+
+      const result = validateMetadata(invalidADR);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Missing required field: date');
+      expect(result.errors).toContain('At least one decider must be specified');
+    });
+
+    it('should reject invalid ID format', () => {
+      const invalidADR: ADR = {
+        id: 'adr-1', // Should be adr-0001
+        title: 'Valid Title Here',
+        status: 'approved',
+        date: '2026-02-06',
+        deciders: ['Tech Lead']
+      };
+
+      const result = validateMetadata(invalidADR);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Invalid ID format. Must be adr-NNNN (e.g., adr-0001)');
+    });
+
+    it('should reject invalid title length', () => {
+      const shortTitle: ADR = {
+        id: 'adr-0001',
+        title: 'Short', // Less than 10 characters
+        status: 'approved',
+        date: '2026-02-06',
+        deciders: ['Tech Lead']
+      };
+
+      const result = validateMetadata(shortTitle);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Title must be 10-100 characters');
+    });
+
+    it('should reject invalid status', () => {
+      const invalidStatus: ADR = {
+        id: 'adr-0001',
+        title: 'Valid Title Here',
+        status: 'invalid-status',
+        date: '2026-02-06',
+        deciders: ['Tech Lead']
+      };
+
+      const result = validateMetadata(invalidStatus);
+      expect(result.valid).toBe(false);
+      expect(result.errors?.some(e => e.includes('Invalid status'))).toBe(true);
+    });
+
+    it('should reject invalid date format', () => {
+      const invalidDate: ADR = {
+        id: 'adr-0001',
+        title: 'Valid Title Here',
+        status: 'approved',
+        date: '2024-02-30', // Invalid date
+        deciders: ['Tech Lead']
+      };
+
+      const result = validateMetadata(invalidDate);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Invalid date format. Must be ISO 8601 (YYYY-MM-DD)');
+    });
+  });
+
+  describe('validateOptionalFields', () => {
+    it('should accept valid optional fields', () => {
+      const adr: ADR = {
+        id: 'adr-0001',
+        title: 'Valid Title Here',
+        status: 'approved',
+        date: '2026-02-06',
+        deciders: ['Tech Lead'],
+        tags: ['database', 'postgresql'],
+        supersedes: ['adr-0002'],
+        superseded_by: 'adr-0003'
+      };
+
+      const result = validateOptionalFields(adr);
+      expect(result.valid).toBe(true);
+      expect(result.warnings).toEqual([]);
+    });
+
+    it('should warn about invalid supersedes format', () => {
+      const adr: ADR = {
+        id: 'adr-0001',
+        title: 'Valid Title Here',
+        status: 'approved',
+        date: '2026-02-06',
+        deciders: ['Tech Lead'],
+        supersedes: ['adr-1', 'invalid-id'] // Invalid formats
+      };
+
+      const result = validateOptionalFields(adr);
+      expect(result.valid).toBe(false);
+      expect(result.warnings?.some(w => w.includes('Invalid ADR ID in supersedes'))).toBe(true);
+    });
+  });
+
+  describe('validateADRReferences', () => {
+    const existingADRs: ADR[] = [
+      {
+        id: 'adr-0001',
+        title: 'First Decision',
+        status: 'approved',
+        date: '2026-01-01',
+        deciders: ['Tech Lead']
+      },
+      {
+        id: 'adr-0002',
+        title: 'Second Decision',
+        status: 'approved',
+        date: '2026-01-02',
+        deciders: ['Tech Lead']
+      }
+    ];
+
+    it('should warn when related_decisions references non-existent ADR', () => {
+      const adr: ADR = {
+        id: 'adr-0003',
+        title: 'Third Decision',
+        status: 'approved',
+        date: '2026-01-03',
+        deciders: ['Tech Lead'],
+        related_decisions: ['adr-0001', 'adr-9999'] // adr-9999 doesn't exist
+      };
+
+      const result = validateADRReferences(adr, existingADRs);
+      expect(result.valid).toBe(false);
+      expect(result.warnings).toContain('Related ADR does not exist: adr-9999');
+    });
+
+    it('should pass when all references exist', () => {
+      const adr: ADR = {
+        id: 'adr-0003',
+        title: 'Third Decision',
+        status: 'approved',
+        date: '2026-01-03',
+        deciders: ['Tech Lead'],
+        related_decisions: ['adr-0001', 'adr-0002']
+      };
+
+      const result = validateADRReferences(adr, existingADRs);
+      expect(result.valid).toBe(true);
+      expect(result.warnings).toEqual([]);
+    });
+  });
+});
+

package/augment-extensions/workflows/adr-support/adr-validator.ts

@@ -0,0 +1,162 @@
+/**
+ * ADR Validation Module
+ * Implements validation rules from validation-rules.md
+ */
+
+export interface ADR {
+  id: string;
+  title: string;
+  status: string;
+  date: string;
+  deciders: string[];
+  tags?: string[];
+  supersedes?: string[];
+  superseded_by?: string;
+  related_decisions?: string[];
+  related_specs?: string[];
+  related_tasks?: string[];
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors?: string[];
+  warnings?: string[];
+}
+
+const VALID_STATUSES = ['draft', 'proposed', 'approved', 'implemented', 'maintained', 'superseded', 'sunset'];
+
+/**
+ * Validate ISO 8601 date format (YYYY-MM-DD)
+ */
+export function isValidISO8601(date: string): boolean {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    return false;
+  }
+
+  const [year, month, day] = date.split('-').map(Number);
+
+  // Check basic ranges
+  if (month < 1 || month > 12 || day < 1 || day > 31) {
+    return false;
+  }
+
+  // Create date in UTC to avoid timezone issues
+  const d = new Date(Date.UTC(year, month - 1, day));
+
+  if (isNaN(d.getTime())) {
+    return false;
+  }
+
+  // Verify the date components match (handles invalid dates like 2024-02-30)
+  return d.getUTCFullYear() === year &&
+         d.getUTCMonth() === month - 1 &&
+         d.getUTCDate() === day;
+}
+
+/**
+ * Validate required metadata fields
+ */
+export function validateMetadata(adr: ADR): ValidationResult {
+  const errors: string[] = [];
+  
+  // ID validation
+  if (!adr.id) {
+    errors.push("Missing required field: id");
+  } else if (!/^adr-\d{4}$/.test(adr.id)) {
+    errors.push("Invalid ID format. Must be adr-NNNN (e.g., adr-0001)");
+  }
+  
+  // Title validation
+  if (!adr.title) {
+    errors.push("Missing required field: title");
+  } else if (adr.title.length < 10 || adr.title.length > 100) {
+    errors.push("Title must be 10-100 characters");
+  }
+  
+  // Status validation
+  if (!adr.status) {
+    errors.push("Missing required field: status");
+  } else if (!VALID_STATUSES.includes(adr.status)) {
+    errors.push(`Invalid status. Must be one of: ${VALID_STATUSES.join(', ')}`);
+  }
+  
+  // Date validation
+  if (!adr.date) {
+    errors.push("Missing required field: date");
+  } else if (!isValidISO8601(adr.date)) {
+    errors.push("Invalid date format. Must be ISO 8601 (YYYY-MM-DD)");
+  }
+  
+  // Deciders validation
+  if (!adr.deciders || adr.deciders.length === 0) {
+    errors.push("At least one decider must be specified");
+  }
+  
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Validate optional fields
+ */
+export function validateOptionalFields(adr: ADR): ValidationResult {
+  const warnings: string[] = [];
+  
+  // Tags validation
+  if (adr.tags && !Array.isArray(adr.tags)) {
+    warnings.push("Tags must be an array");
+  }
+  
+  // Supersedes validation
+  if (adr.supersedes) {
+    if (!Array.isArray(adr.supersedes)) {
+      warnings.push("Supersedes must be an array");
+    } else {
+      adr.supersedes.forEach(id => {
+        if (!/^adr-\d{4}$/.test(id)) {
+          warnings.push(`Invalid ADR ID in supersedes: ${id}`);
+        }
+      });
+    }
+  }
+  
+  // Superseded_by validation
+  if (adr.superseded_by && !/^adr-\d{4}$/.test(adr.superseded_by)) {
+    warnings.push(`Invalid ADR ID in superseded_by: ${adr.superseded_by}`);
+  }
+  
+  return { valid: warnings.length === 0, warnings };
+}
+
+/**
+ * Validate ADR references (related_decisions, supersedes, etc.)
+ */
+export function validateADRReferences(adr: ADR, allADRs: ADR[]): ValidationResult {
+  const warnings: string[] = [];
+  const adrIds = new Set(allADRs.map(a => a.id));
+  
+  // Validate supersedes references
+  if (adr.supersedes) {
+    adr.supersedes.forEach(id => {
+      if (!adrIds.has(id)) {
+        warnings.push(`Referenced ADR does not exist: ${id}`);
+      }
+    });
+  }
+  
+  // Validate superseded_by reference
+  if (adr.superseded_by && !adrIds.has(adr.superseded_by)) {
+    warnings.push(`Referenced ADR does not exist: ${adr.superseded_by}`);
+  }
+  
+  // Validate related_decisions
+  if (adr.related_decisions) {
+    adr.related_decisions.forEach(id => {
+      if (!adrIds.has(id)) {
+        warnings.push(`Related ADR does not exist: ${id}`);
+      }
+    });
+  }
+  
+  return { valid: warnings.length === 0, warnings };
+}
+