cgd-validator 0.1.0 → 0.1.1

package/index.js

@@ -12,7 +12,10 @@
  * @license CC-BY-4.0
  */
 
-const VERSION = '0.1.0';
+const VERSION = '0.1.1';
+
+// Valid Clarity Gate versions
+const VALID_VERSIONS = ['1.0', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6'];
 
 /**
  * Parse YAML frontmatter from CGD file
@@ -20,16 +23,23 @@ const VERSION = '0.1.0';
  * @returns {Object|null} Parsed frontmatter or null
  */
 function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  // BUG FIX #3: Strip BOM and leading whitespace
+  const cleanContent = content.replace(/^\uFEFF/, '').trimStart();
+  
+  const match = cleanContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!match) return null;
   
   const frontmatter = {};
-  const lines = match[1].split('\n');
+  const lines = match[1].split(/\r?\n/);
   
   for (const line of lines) {
-    const [key, ...valueParts] = line.split(':');
-    if (key && valueParts.length) {
-      frontmatter[key.trim()] = valueParts.join(':').trim();
+    const colonIndex = line.indexOf(':');
+    if (colonIndex > 0) {
+      const key = line.slice(0, colonIndex).trim();
+      const value = line.slice(colonIndex + 1).trim();
+      if (key) {
+        frontmatter[key] = value;
+      }
     }
   }
   
@@ -45,8 +55,11 @@ function validate(content) {
   const errors = [];
   const warnings = [];
   
+  // Strip BOM if present
+  const cleanContent = content.replace(/^\uFEFF/, '');
+  
   // Required: YAML frontmatter
-  const frontmatter = parseFrontmatter(content);
+  const frontmatter = parseFrontmatter(cleanContent);
   if (!frontmatter) {
     errors.push({
       code: 'MISSING_FRONTMATTER',
@@ -54,23 +67,57 @@ function validate(content) {
       line: 1
     });
   } else {
-    // Required frontmatter fields
+    // Required: clarity-gate-version
     if (!frontmatter['clarity-gate-version']) {
       errors.push({
         code: 'MISSING_VERSION',
         message: 'Frontmatter must contain "clarity-gate-version"',
         line: 1
       });
+    } else {
+      // BUG FIX #8: Validate version is a known version
+      const version = frontmatter['clarity-gate-version'].trim();
+      if (!VALID_VERSIONS.includes(version)) {
+        warnings.push({
+          code: 'UNKNOWN_VERSION',
+          message: `Clarity Gate version "${version}" is not recognized. Known versions: ${VALID_VERSIONS.join(', ')}`,
+          line: 1
+        });
+      }
     }
     
+    // Required: verified-date
     if (!frontmatter['verified-date']) {
       errors.push({
         code: 'MISSING_VERIFIED_DATE',
         message: 'Frontmatter must contain "verified-date"',
         line: 1
       });
+    } else {
+      // BUG FIX #9: Validate date format and not in future
+      const dateStr = frontmatter['verified-date'].trim();
+      const dateMatch = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+      if (!dateMatch) {
+        warnings.push({
+          code: 'INVALID_DATE_FORMAT',
+          message: `verified-date "${dateStr}" should be in YYYY-MM-DD format`,
+          line: 1
+        });
+      } else {
+        const docDate = new Date(dateStr);
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        if (docDate > today) {
+          errors.push({
+            code: 'FUTURE_DATE',
+            message: `verified-date (${dateStr}) is in the future`,
+            line: 1
+          });
+        }
+      }
     }
     
+    // Required: verified-by
     if (!frontmatter['verified-by']) {
       errors.push({
         code: 'MISSING_VERIFIED_BY',
@@ -79,45 +126,84 @@ function validate(content) {
       });
     }
     
+    // Required: hitl-status
     if (!frontmatter['hitl-status']) {
       errors.push({
         code: 'MISSING_HITL_STATUS',
         message: 'Frontmatter must contain "hitl-status"',
         line: 1
       });
+    } else {
+      // BUG FIX #10: Case-insensitive comparison, trim whitespace
+      const hitlStatus = frontmatter['hitl-status'].trim().toUpperCase();
+      if (hitlStatus !== 'CONFIRMED') {
+        warnings.push({
+          code: 'HITL_NOT_CONFIRMED',
+          message: `HITL status is "${frontmatter['hitl-status']}" - should be "CONFIRMED" for full validation`,
+          line: 1
+        });
+      }
     }
     
-    // Warning: HITL not confirmed
-    if (frontmatter['hitl-status'] && frontmatter['hitl-status'] !== 'CONFIRMED') {
+    // BUG FIX #7: Check for points-passed
+    if (!frontmatter['points-passed']) {
       warnings.push({
-        code: 'HITL_NOT_CONFIRMED',
-        message: `HITL status is "${frontmatter['hitl-status']}" - should be "CONFIRMED" for full validation`,
+        code: 'MISSING_POINTS_PASSED',
+        message: 'Frontmatter should contain "points-passed" listing which verification points were checked',
         line: 1
       });
     }
   }
   
-  // Required: Verification summary at end
-  if (!content.includes('## Clarity Gate Verification')) {
+  // Required: Verification summary at end (case-insensitive)
+  if (!/##\s*clarity\s+gate\s+verification/i.test(cleanContent)) {
     errors.push({
       code: 'MISSING_VERIFICATION_SUMMARY',
       message: 'Document must contain "## Clarity Gate Verification" section',
       line: null
     });
+  } else {
+    // BUG FIX #4: Check that section contains a table
+    const verificationSection = cleanContent.match(/##\s*clarity\s+gate\s+verification[\s\S]*$/i);
+    if (verificationSection && !verificationSection[0].includes('|')) {
+      warnings.push({
+        code: 'NO_TABLE_IN_VERIFICATION',
+        message: 'Clarity Gate Verification section should contain a points table',
+        line: null
+      });
+    }
+  }
+  
+  // BUG FIX #2: Check EACH projection phrase for markers
+  const projectionPhrases = cleanContent.match(/will\s+(be|reach|reduce|increase|decrease|grow|achieve)/gi) || [];
+  let unmarkedProjections = 0;
+  
+  for (const phrase of projectionPhrases) {
+    // Find the phrase in content and check if it has a marker nearby
+    const phraseIndex = cleanContent.toLowerCase().indexOf(phrase.toLowerCase());
+    if (phraseIndex >= 0) {
+      // Check 50 chars before and after for *(projected)* or similar
+      const context = cleanContent.slice(Math.max(0, phraseIndex - 50), phraseIndex + phrase.length + 50);
+      if (!/\*\(projected|\(projected\)|\*projected\*/i.test(context)) {
+        unmarkedProjections++;
+      }
+    }
   }
   
-  // Warning: Projections without markers
-  if (content.match(/will be|will reach|will reduce/i) && !content.match(/\*\(projected/i)) {
+  if (unmarkedProjections > 0) {
     warnings.push({
       code: 'UNMARKED_PROJECTION',
-      message: 'Document contains "will be/reach/reduce" without *(projected)* marker',
+      message: `Found ${unmarkedProjections} projection phrase(s) without nearby *(projected)* marker`,
       line: null
     });
   }
   
-  // Warning: Vague quantifiers without annotation
-  const vagueQuantifiers = content.match(/\b(several|many|most|some)\b(?!\s*\*\()/gi);
-  if (vagueQuantifiers && vagueQuantifiers.length > 0) {
+  // BUG FIX #5: Better vague quantifier detection - exclude those in annotations
+  // Split content into annotated and non-annotated parts
+  const withoutAnnotations = cleanContent.replace(/\*\([^)]*\)\*/g, ''); // Remove *(...)* 
+  const vagueQuantifiers = withoutAnnotations.match(/\b(several|many|most|some)\b/gi) || [];
+  
+  if (vagueQuantifiers.length > 0) {
     warnings.push({
       code: 'UNMARKED_VAGUE_QUANTIFIER',
       message: `Found ${vagueQuantifiers.length} vague quantifier(s) without annotation (several, many, most, some)`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cgd-validator",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Validator for Clarity-Gated Document (.cgd) files - verified documents for safe LLM ingestion",
   "main": "index.js",
   "types": "index.d.ts",