@forwardimpact/schema 0.4.0 → 0.7.0

package/{lib → src}/validation.js

@@ -6,7 +6,6 @@
 
 import {
   Capability,
-  Stage,
   getSkillLevelIndex,
   getBehaviourMaturityIndex,
 } from "./levels.js";
@@ -150,14 +149,13 @@ function validateSkill(skill, index, requiredStageIds = []) {
         ),
       );
     } else {
-      // Validate each stage
-      const validStageIds = Object.values(Stage);
+      // Validate each stage against loaded stage data
       for (const [stageId, stageData] of Object.entries(skill.agent.stages)) {
-        if (!validStageIds.includes(stageId)) {
+        if (requiredStageIds.length > 0 && !requiredStageIds.includes(stageId)) {
           errors.push(
             createError(
               "INVALID_VALUE",
-              `Invalid stage ID: ${stageId}. Must be one of: ${validStageIds.join(", ")}`,
+              `Invalid stage ID: ${stageId}. Must be one of: ${requiredStageIds.join(", ")}`,
               `${agentPath}.stages.${stageId}`,
               stageId,
             ),
@@ -184,41 +182,41 @@ function validateSkill(skill, index, requiredStageIds = []) {
             ),
           );
         }
-        // activities is required and must be an array
-        if (!stageData.activities) {
+        // readChecklist is required and must be an array
+        if (!stageData.readChecklist) {
           errors.push(
             createError(
               "MISSING_REQUIRED",
-              `Stage ${stageId} missing activities`,
-              `${stagePath}.activities`,
+              `Stage ${stageId} missing readChecklist`,
+              `${stagePath}.readChecklist`,
             ),
           );
-        } else if (!Array.isArray(stageData.activities)) {
+        } else if (!Array.isArray(stageData.readChecklist)) {
           errors.push(
             createError(
               "INVALID_VALUE",
-              `Stage ${stageId} activities must be an array`,
-              `${stagePath}.activities`,
-              stageData.activities,
+              `Stage ${stageId} readChecklist must be an array`,
+              `${stagePath}.readChecklist`,
+              stageData.readChecklist,
             ),
           );
         }
-        // ready is required and must be an array (these become checklist items)
-        if (!stageData.ready) {
+        // confirmChecklist is required and must be an array (these become checklist items)
+        if (!stageData.confirmChecklist) {
           errors.push(
             createError(
               "MISSING_REQUIRED",
-              `Stage ${stageId} missing ready criteria`,
-              `${stagePath}.ready`,
+              `Stage ${stageId} missing confirmChecklist`,
+              `${stagePath}.confirmChecklist`,
             ),
           );
-        } else if (!Array.isArray(stageData.ready)) {
+        } else if (!Array.isArray(stageData.confirmChecklist)) {
           errors.push(
             createError(
               "INVALID_VALUE",
-              `Stage ${stageId} ready must be an array`,
-              `${stagePath}.ready`,
-              stageData.ready,
+              `Stage ${stageId} confirmChecklist must be an array`,
+              `${stagePath}.confirmChecklist`,
+              stageData.confirmChecklist,
             ),
           );
         }
@@ -284,7 +282,7 @@ function validateSkill(skill, index, requiredStageIds = []) {
       errors.push(
         createError(
           "INVALID_FIELD",
-          "Skill agent 'verificationCriteria' field is not supported. Use stages.{stage}.ready instead.",
+          "Skill agent 'verificationCriteria' field is not supported. Use stages.{stage}.confirmChecklist instead.",
           `${agentPath}.verificationCriteria`,
         ),
       );
@@ -1249,15 +1247,6 @@ function validateStage(stage, index) {
 
   if (!stage.id) {
     errors.push(createError("MISSING_REQUIRED", "Stage missing id", path));
-  } else if (!Object.values(Stage).includes(stage.id)) {
-    errors.push(
-      createError(
-        "INVALID_VALUE",
-        `Invalid stage id: ${stage.id}`,
-        `${path}.id`,
-        stage.id,
-      ),
-    );
   }
 
   if (!stage.name) {
@@ -1774,6 +1763,7 @@ export function validateQuestionBank(questionBank, skills, behaviours) {
   const warnings = [];
   const skillIds = new Set(skills.map((s) => s.id));
   const behaviourIds = new Set(behaviours.map((b) => b.id));
+  const validRoleTypes = ["professionalQuestions", "managementQuestions"];
 
   if (!questionBank) {
     return createValidationResult(false, [
@@ -1784,7 +1774,7 @@ export function validateQuestionBank(questionBank, skills, behaviours) {
   // Validate skill questions
   if (questionBank.skillLevels) {
     Object.entries(questionBank.skillLevels).forEach(
-      ([skillId, levelQuestions]) => {
+      ([skillId, roleTypeQuestions]) => {
         if (!skillIds.has(skillId)) {
           errors.push(
             createError(
@@ -1795,27 +1785,46 @@ export function validateQuestionBank(questionBank, skills, behaviours) {
             ),
           );
         }
-        Object.entries(levelQuestions || {}).forEach(([level, questions]) => {
-          if (getSkillLevelIndex(level) === -1) {
-            errors.push(
-              createError(
-                "INVALID_VALUE",
-                `Question bank has invalid skill level: ${level}`,
-                `questionBank.skillLevels.${skillId}.${level}`,
-                level,
-              ),
-            );
-          }
-          if (!Array.isArray(questions) || questions.length === 0) {
-            warnings.push(
-              createWarning(
-                "EMPTY_QUESTIONS",
-                `No questions for skill ${skillId} at level ${level}`,
-                `questionBank.skillLevels.${skillId}.${level}`,
-              ),
+        // Validate each role type (professional/management)
+        Object.entries(roleTypeQuestions || {}).forEach(
+          ([roleType, levelQuestions]) => {
+            if (!validRoleTypes.includes(roleType)) {
+              errors.push(
+                createError(
+                  "INVALID_VALUE",
+                  `Question bank has invalid role type: ${roleType}`,
+                  `questionBank.skillLevels.${skillId}.${roleType}`,
+                  roleType,
+                ),
+              );
+              return;
+            }
+            // Validate each level within the role type
+            Object.entries(levelQuestions || {}).forEach(
+              ([level, questions]) => {
+                if (getSkillLevelIndex(level) === -1) {
+                  errors.push(
+                    createError(
+                      "INVALID_VALUE",
+                      `Question bank has invalid skill level: ${level}`,
+                      `questionBank.skillLevels.${skillId}.${roleType}.${level}`,
+                      level,
+                    ),
+                  );
+                }
+                if (!Array.isArray(questions) || questions.length === 0) {
+                  warnings.push(
+                    createWarning(
+                      "EMPTY_QUESTIONS",
+                      `No questions for skill ${skillId} (${roleType}) at level ${level}`,
+                      `questionBank.skillLevels.${skillId}.${roleType}.${level}`,
+                    ),
+                  );
+                }
+              },
             );
-          }
-        });
+          },
+        );
       },
     );
   }
@@ -1823,7 +1832,7 @@ export function validateQuestionBank(questionBank, skills, behaviours) {
   // Validate behaviour questions
   if (questionBank.behaviourMaturities) {
     Object.entries(questionBank.behaviourMaturities).forEach(
-      ([behaviourId, maturityQuestions]) => {
+      ([behaviourId, roleTypeQuestions]) => {
         if (!behaviourIds.has(behaviourId)) {
           errors.push(
             createError(
@@ -1834,27 +1843,44 @@ export function validateQuestionBank(questionBank, skills, behaviours) {
             ),
           );
         }
-        Object.entries(maturityQuestions || {}).forEach(
-          ([maturity, questions]) => {
-            if (getBehaviourMaturityIndex(maturity) === -1) {
+        // Validate each role type (professional/management)
+        Object.entries(roleTypeQuestions || {}).forEach(
+          ([roleType, maturityQuestions]) => {
+            if (!validRoleTypes.includes(roleType)) {
               errors.push(
                 createError(
                   "INVALID_VALUE",
-                  `Question bank has invalid behaviour maturity: ${maturity}`,
-                  `questionBank.behaviourMaturities.${behaviourId}.${maturity}`,
-                  maturity,
-                ),
-              );
-            }
-            if (!Array.isArray(questions) || questions.length === 0) {
-              warnings.push(
-                createWarning(
-                  "EMPTY_QUESTIONS",
-                  `No questions for behaviour ${behaviourId} at maturity ${maturity}`,
-                  `questionBank.behaviourMaturities.${behaviourId}.${maturity}`,
+                  `Question bank has invalid role type: ${roleType}`,
+                  `questionBank.behaviourMaturities.${behaviourId}.${roleType}`,
+                  roleType,
                 ),
               );
+              return;
             }
+            // Validate each maturity level within the role type
+            Object.entries(maturityQuestions || {}).forEach(
+              ([maturity, questions]) => {
+                if (getBehaviourMaturityIndex(maturity) === -1) {
+                  errors.push(
+                    createError(
+                      "INVALID_VALUE",
+                      `Question bank has invalid behaviour maturity: ${maturity}`,
+                      `questionBank.behaviourMaturities.${behaviourId}.${roleType}.${maturity}`,
+                      maturity,
+                    ),
+                  );
+                }
+                if (!Array.isArray(questions) || questions.length === 0) {
+                  warnings.push(
+                    createWarning(
+                      "EMPTY_QUESTIONS",
+                      `No questions for behaviour ${behaviourId} (${roleType}) at maturity ${maturity}`,
+                      `questionBank.behaviourMaturities.${behaviourId}.${roleType}.${maturity}`,
+                    ),
+                  );
+                }
+              },
+            );
           },
         );
       },
@@ -1960,7 +1986,7 @@ export function validateAgentData({ humanData, agentData }) {
 
   // Validate skills with agent sections have complete stage coverage
   const skillsWithAgent = (humanData.skills || []).filter((s) => s.agent);
-  const requiredStages = ["plan", "code", "review"];
+  const requiredStages = ["plan", "onboard", "code", "review"];
 
   for (const skill of skillsWithAgent) {
     const stages = skill.agent.stages || {};
@@ -1988,28 +2014,28 @@ export function validateAgentData({ humanData, agentData }) {
         );
       }
       if (
-        !stageData.activities ||
-        !Array.isArray(stageData.activities) ||
-        stageData.activities.length === 0
+        !stageData.readChecklist ||
+        !Array.isArray(stageData.readChecklist) ||
+        stageData.readChecklist.length === 0
       ) {
         errors.push(
           createError(
             "MISSING_REQUIRED",
-            `Skill '${skill.id}' agent stage '${stageId}' missing or empty activities`,
-            `skills.${skill.id}.agent.stages.${stageId}.activities`,
+            `Skill '${skill.id}' agent stage '${stageId}' missing or empty readChecklist`,
+            `skills.${skill.id}.agent.stages.${stageId}.readChecklist`,
           ),
         );
       }
       if (
-        !stageData.ready ||
-        !Array.isArray(stageData.ready) ||
-        stageData.ready.length === 0
+        !stageData.confirmChecklist ||
+        !Array.isArray(stageData.confirmChecklist) ||
+        stageData.confirmChecklist.length === 0
       ) {
         errors.push(
           createError(
             "MISSING_REQUIRED",
-            `Skill '${skill.id}' agent stage '${stageId}' missing or empty ready criteria`,
-            `skills.${skill.id}.agent.stages.${stageId}.ready`,
+            `Skill '${skill.id}' agent stage '${stageId}' missing or empty confirmChecklist`,
+            `skills.${skill.id}.agent.stages.${stageId}.confirmChecklist`,
           ),
         );
       }