@forwardimpact/pathway 0.1.0 → 0.3.0

package/app/formatters/discipline/microdata.js

@@ -0,0 +1,117 @@
+/**
+ * Discipline formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with discipline.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  linkTag,
+  section,
+  ul,
+  escapeHtml,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareDisciplinesList, prepareDisciplineDetail } from "./shared.js";
+
+/**
+ * Format discipline list as microdata HTML
+ * @param {Array} disciplines - Raw discipline entities
+ * @returns {string} HTML with microdata
+ */
+export function disciplineListToMicrodata(disciplines) {
+  const { items } = prepareDisciplinesList(disciplines);
+
+  const content = items
+    .map(
+      (
+        d,
+      ) => `${openTag("article", { itemtype: "Discipline", itemid: `#${d.id}` })}
+${prop("h2", "specialization", d.name)}
+<p>Core: ${d.coreSkillsCount} | Supporting: ${d.supportingSkillsCount} | Broad: ${d.broadSkillsCount}</p>
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Disciplines",
+    `<main>
+<h1>Disciplines</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format discipline detail as microdata HTML
+ * @param {Object} discipline - Raw discipline entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.skills - All skills
+ * @param {Array} context.behaviours - All behaviours
+ * @param {boolean} [context.showBehaviourModifiers=true] - Whether to show behaviour modifiers section
+ * @returns {string} HTML with microdata
+ */
+export function disciplineToMicrodata(
+  discipline,
+  { skills, behaviours, showBehaviourModifiers = true } = {},
+) {
+  const view = prepareDisciplineDetail(discipline, { skills, behaviours });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Core skills - using coreSkills property
+  if (view.coreSkills.length > 0) {
+    const skillLinks = view.coreSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "coreSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Core Skills", ul(skillLinks), 2));
+  }
+
+  // Supporting skills - using supportingSkills property
+  if (view.supportingSkills.length > 0) {
+    const skillLinks = view.supportingSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "supportingSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Supporting Skills", ul(skillLinks), 2));
+  }
+
+  // Broad skills - using broadSkills property
+  if (view.broadSkills.length > 0) {
+    const skillLinks = view.broadSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "broadSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Broad Skills", ul(skillLinks), 2));
+  }
+
+  // Behaviour modifiers - using BehaviourModifier itemtype
+  if (showBehaviourModifiers && view.behaviourModifiers.length > 0) {
+    const modifierItems = view.behaviourModifiers.map((b) => {
+      const modifierStr = b.modifier > 0 ? `+${b.modifier}` : `${b.modifier}`;
+      return `${openTag("span", { itemtype: "BehaviourModifier", itemprop: "behaviourModifiers" })}
+${linkTag("targetBehaviour", `#${b.id}`)}
+<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a>: ${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>
+</span>`;
+    });
+    sections.push(section("Behaviour Modifiers", ul(modifierItems), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Discipline", itemid: `#${view.id}` })}
+${prop("h1", "specialization", view.name)}
+${metaTag("id", view.id)}
+${discipline.roleTitle ? prop("p", "roleTitle", discipline.roleTitle) : ""}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/discipline/shared.js

@@ -35,16 +35,18 @@ export function getDisciplineDisplayName(discipline) {
  * @property {number} coreSkillsCount
  * @property {number} supportingSkillsCount
  * @property {number} broadSkillsCount
+ * @property {boolean} isProfessional
+ * @property {boolean} isManagement
  */
 
 /**
- * Transform disciplines for list view
- * @param {Array} disciplines - Raw discipline entities
- * @param {number} [descriptionLimit=120] - Maximum description length
- * @returns {{ items: DisciplineListItem[] }}
+ * Transform a single discipline to list item format
+ * @param {Object} discipline - Raw discipline entity
+ * @param {number} descriptionLimit - Maximum description length
+ * @returns {DisciplineListItem}
  */
-export function prepareDisciplinesList(disciplines, descriptionLimit = 120) {
-  const items = disciplines.map((discipline) => ({
+function disciplineToListItem(discipline, descriptionLimit) {
+  return {
     id: discipline.id,
     name: getDisciplineDisplayName(discipline),
     description: discipline.description,
@@ -52,9 +54,48 @@ export function prepareDisciplinesList(disciplines, descriptionLimit = 120) {
     coreSkillsCount: discipline.coreSkills?.length || 0,
     supportingSkillsCount: discipline.supportingSkills?.length || 0,
     broadSkillsCount: discipline.broadSkills?.length || 0,
-  }));
+    isProfessional: discipline.isProfessional || false,
+    isManagement: discipline.isManagement || false,
+  };
+}
+
+/**
+ * Transform disciplines for list view, grouped by type (professional/management)
+ * @param {Array} disciplines - Raw discipline entities
+ * @param {number} [descriptionLimit=120] - Maximum description length
+ * @returns {{ items: DisciplineListItem[], groups: Object<string, DisciplineListItem[]>, groupOrder: string[] }}
+ */
+export function prepareDisciplinesList(disciplines, descriptionLimit = 120) {
+  const professional = [];
+  const management = [];
+
+  for (const discipline of disciplines) {
+    const item = disciplineToListItem(discipline, descriptionLimit);
+    if (discipline.isManagement) {
+      management.push(item);
+    } else {
+      // Default to professional if not explicitly management
+      professional.push(item);
+    }
+  }
+
+  // Groups in display order: professional first, then management
+  const groups = {};
+  const groupOrder = [];
+
+  if (professional.length > 0) {
+    groups.professional = professional;
+    groupOrder.push("professional");
+  }
+  if (management.length > 0) {
+    groups.management = management;
+    groupOrder.push("management");
+  }
+
+  // items maintains backward compatibility (professional first, then management)
+  const items = [...professional, ...management];
 
-  return { items };
+  return { items, groups, groupOrder };
 }
 
 /**

package/app/formatters/driver/dom.js

@@ -6,6 +6,7 @@ import { div, heading1, heading2, p, a, span } from "../../lib/render.js";
 import { createBackLink } from "../../components/nav.js";
 import { prepareDriverDetail } from "./shared.js";
 import { getConceptEmoji } from "../../model/levels.js";
+import { createJsonLdScript, driverToJsonLd } from "../json-ld.js";
 
 /**
  * Format driver detail as DOM elements
@@ -25,6 +26,8 @@ export function driverToDOM(
   const emoji = framework ? getConceptEmoji(framework, "driver") : "🎯";
   return div(
     { className: "detail-page driver-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(driverToJsonLd(driver, { skills, behaviours })),
     // Header
     div(
       { className: "page-header" },

package/app/formatters/driver/microdata.js

@@ -0,0 +1,91 @@
+/**
+ * Driver formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with drivers.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  section,
+  ul,
+  escapeHtml,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareDriversList, prepareDriverDetail } from "./shared.js";
+
+/**
+ * Format driver list as microdata HTML
+ * @param {Array} drivers - Raw driver entities
+ * @returns {string} HTML with microdata
+ */
+export function driverListToMicrodata(drivers) {
+  const { items } = prepareDriversList(drivers);
+
+  const content = items
+    .map(
+      (
+        driver,
+      ) => `${openTag("article", { itemtype: "Driver", itemid: `#${driver.id}` })}
+${prop("h2", "name", driver.name)}
+${prop("p", "description", driver.truncatedDescription)}
+<p>Skills: ${driver.contributingSkillsCount} | Behaviours: ${driver.contributingBehavioursCount}</p>
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Drivers",
+    `<main>
+<h1>Drivers</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format driver detail as microdata HTML
+ * @param {Object} driver - Raw driver entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.skills - All skills
+ * @param {Array} context.behaviours - All behaviours
+ * @returns {string} HTML with microdata
+ */
+export function driverToMicrodata(driver, { skills, behaviours }) {
+  const view = prepareDriverDetail(driver, { skills, behaviours });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Contributing skills - using contributingSkills property
+  if (view.contributingSkills.length > 0) {
+    const skillLinks = view.contributingSkills.map(
+      (s) =>
+        `${openTag("span", { itemprop: "contributingSkills" })}<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a></span>`,
+    );
+    sections.push(section("Contributing Skills", ul(skillLinks), 2));
+  }
+
+  // Contributing behaviours - using contributingBehaviours property
+  if (view.contributingBehaviours.length > 0) {
+    const behaviourLinks = view.contributingBehaviours.map(
+      (b) =>
+        `${openTag("span", { itemprop: "contributingBehaviours" })}<a href="#${escapeHtml(b.id)}">${escapeHtml(b.name)}</a></span>`,
+    );
+    sections.push(section("Contributing Behaviours", ul(behaviourLinks), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Driver", itemid: `#${view.id}` })}
+${prop("h1", "name", view.name)}
+${metaTag("id", view.id)}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/grade/dom.js

@@ -14,6 +14,7 @@ import {
   tr,
   th,
   td,
+  formatLevel,
 } from "../../lib/render.js";
 import { createBackLink } from "../../components/nav.js";
 import { createLevelDots } from "../../components/detail.js";
@@ -24,6 +25,7 @@ import {
 } from "../../model/levels.js";
 import { createJobBuilderButton } from "../../components/action-buttons.js";
 import { prepareGradeDetail } from "./shared.js";
+import { createJsonLdScript, gradeToJsonLd } from "../json-ld.js";
 
 /**
  * Format grade detail as DOM elements
@@ -38,6 +40,8 @@ export function gradeToDOM(grade, { framework, showBackLink = true } = {}) {
   const emoji = framework ? getConceptEmoji(framework, "grade") : "📊";
   return div(
     { className: "detail-page grade-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(gradeToJsonLd(grade)),
     // Header
     div(
       { className: "page-header" },
@@ -99,10 +103,7 @@ export function gradeToDOM(grade, { framework, showBackLink = true } = {}) {
             ...Object.entries(view.expectations).map(([key, value]) =>
               div(
                 { className: "list-item" },
-                p(
-                  { className: "label" },
-                  key.charAt(0).toUpperCase() + key.slice(1),
-                ),
+                p({ className: "label" }, formatLevel(key)),
                 p({}, value),
               ),
             ),

package/app/formatters/grade/microdata.js

@@ -0,0 +1,151 @@
+/**
+ * Grade formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with grades.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  linkTag,
+  section,
+  dl,
+  escapeHtml,
+  formatLevelName,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareGradesList, prepareGradeDetail } from "./shared.js";
+
+/**
+ * Format grade list as microdata HTML
+ * @param {Array} grades - Raw grade entities
+ * @returns {string} HTML with microdata
+ */
+export function gradeListToMicrodata(grades) {
+  const { items } = prepareGradesList(grades);
+
+  const content = items
+    .map(
+      (g) => `${openTag("article", { itemtype: "Grade", itemid: `#${g.id}` })}
+${prop("h2", "id", g.id)}
+<p>${escapeHtml(g.displayName)}</p>
+${g.typicalExperienceRange ? prop("p", "typicalExperienceRange", g.typicalExperienceRange) : ""}
+${metaTag("ordinalRank", String(g.ordinalRank))}
+</article>`,
+    )
+    .join("\n");
+
+  return htmlDocument(
+    "Grades",
+    `<main>
+<h1>Grades</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format grade detail as microdata HTML
+ * @param {Object} grade - Raw grade entity
+ * @returns {string} HTML with microdata
+ */
+export function gradeToMicrodata(grade) {
+  const view = prepareGradeDetail(grade);
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Titles section
+  if (view.professionalTitle || view.managementTitle) {
+    const titlePairs = [];
+    if (view.professionalTitle) {
+      titlePairs.push({
+        term: "Professional Track",
+        definition: view.professionalTitle,
+        itemprop: "professionalTitle",
+      });
+    }
+    if (view.managementTitle) {
+      titlePairs.push({
+        term: "Management Track",
+        definition: view.managementTitle,
+        itemprop: "managementTitle",
+      });
+    }
+    sections.push(section("Titles", dl(titlePairs), 2));
+  }
+
+  // Base skill levels - using BaseSkillLevels itemtype
+  if (view.baseSkillLevels && Object.keys(view.baseSkillLevels).length > 0) {
+    const levelPairs = Object.entries(view.baseSkillLevels).map(
+      ([type, level]) => ({
+        term: formatLevelName(type),
+        definition: formatLevelName(level),
+        itemprop: type,
+      }),
+    );
+    sections.push(
+      section(
+        "Base Skill Levels",
+        `${openTag("div", { itemtype: "BaseSkillLevels", itemprop: "baseSkillLevels" })}
+${dl(levelPairs)}
+</div>`,
+        2,
+      ),
+    );
+  }
+
+  // Base behaviour maturity - link to BehaviourMaturity
+  if (
+    view.baseBehaviourMaturity &&
+    Object.keys(view.baseBehaviourMaturity).length > 0
+  ) {
+    const maturityPairs = Object.entries(view.baseBehaviourMaturity).map(
+      ([type, maturity]) => ({
+        term: formatLevelName(type),
+        definition: formatLevelName(maturity),
+      }),
+    );
+    // Handle both single value and object cases
+    const maturityContent =
+      typeof grade.baseBehaviourMaturity === "string"
+        ? `${linkTag("baseBehaviourMaturity", `#${grade.baseBehaviourMaturity}`)}
+<p>${formatLevelName(grade.baseBehaviourMaturity)}</p>`
+        : dl(maturityPairs);
+    sections.push(section("Base Behaviour Maturity", maturityContent, 2));
+  }
+
+  // Expectations - using GradeExpectations itemtype
+  if (view.expectations && Object.keys(view.expectations).length > 0) {
+    const expectationPairs = Object.entries(view.expectations).map(
+      ([key, value]) => ({
+        term: formatLevelName(key),
+        definition: value,
+        itemprop: key,
+      }),
+    );
+    sections.push(
+      section(
+        "Expectations",
+        `${openTag("div", { itemtype: "GradeExpectations", itemprop: "expectations" })}
+${dl(expectationPairs)}
+</div>`,
+        2,
+      ),
+    );
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Grade", itemid: `#${view.id}` })}
+<h1>${prop("span", "id", view.id)} — ${escapeHtml(view.displayName)}</h1>
+${metaTag("ordinalRank", String(view.ordinalRank))}
+${view.typicalExperienceRange ? prop("p", "typicalExperienceRange", `Experience: ${view.typicalExperienceRange}`) : ""}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(`${view.id} - ${view.displayName}`, body);
+}

package/app/formatters/index.js

@@ -2,11 +2,12 @@
  * Formatter Layer
  *
  * Export all formatters for easy importing.
- * Formatters transform presenter output into specific formats (DOM, markdown)
+ * Formatters transform presenter output into specific formats (DOM, markdown, microdata)
  */
 
 // Shared utilities
 export * from "./shared.js";
+export * from "./microdata-shared.js";
 
 // Job formatters
 export { jobToMarkdown } from "./job/markdown.js";
@@ -22,10 +23,15 @@ export { progressToDOM } from "./progress/dom.js";
 
 // Driver formatters
 export { driverToDOM } from "./driver/dom.js";
+export {
+  driverListToMicrodata,
+  driverToMicrodata,
+} from "./driver/microdata.js";
 
 // Skill formatters
 export { skillListToMarkdown, skillToMarkdown } from "./skill/markdown.js";
 export { skillToDOM } from "./skill/dom.js";
+export { skillListToMicrodata, skillToMicrodata } from "./skill/microdata.js";
 
 // Behaviour formatters
 export {
@@ -33,6 +39,10 @@ export {
   behaviourToMarkdown,
 } from "./behaviour/markdown.js";
 export { behaviourToDOM } from "./behaviour/dom.js";
+export {
+  behaviourListToMicrodata,
+  behaviourToMicrodata,
+} from "./behaviour/microdata.js";
 
 // Discipline formatters
 export {
@@ -40,11 +50,32 @@ export {
   disciplineToMarkdown,
 } from "./discipline/markdown.js";
 export { disciplineToDOM } from "./discipline/dom.js";
+export {
+  disciplineListToMicrodata,
+  disciplineToMicrodata,
+} from "./discipline/microdata.js";
 
 // Grade formatters
 export { gradeListToMarkdown, gradeToMarkdown } from "./grade/markdown.js";
 export { gradeToDOM } from "./grade/dom.js";
+export { gradeListToMicrodata, gradeToMicrodata } from "./grade/microdata.js";
 
 // Track formatters
 export { trackListToMarkdown, trackToMarkdown } from "./track/markdown.js";
 export { trackToDOM } from "./track/dom.js";
+export { trackListToMicrodata, trackToMicrodata } from "./track/microdata.js";
+
+// Stage formatters
+export { stageListToMicrodata, stageToMicrodata } from "./stage/microdata.js";
+
+// JSON-LD formatters
+export {
+  createJsonLdScript,
+  skillToJsonLd,
+  behaviourToJsonLd,
+  disciplineToJsonLd,
+  trackToJsonLd,
+  gradeToJsonLd,
+  driverToJsonLd,
+  stageToJsonLd,
+} from "./json-ld.js";

package/app/formatters/interview/shared.js

@@ -116,7 +116,7 @@ export function prepareInterviewDetail({
   questions,
   interviewType = "full",
 }) {
-  if (!discipline || !grade || !track) return null;
+  if (!discipline || !grade) return null;
 
   const job = getOrCreateJob({
     discipline,
@@ -171,8 +171,8 @@ export function prepareInterviewDetail({
     disciplineId: discipline.id,
     disciplineName: discipline.specialization || discipline.name,
     gradeId: grade.id,
-    trackId: track.id,
-    trackName: track.name,
+    trackId: track?.id || null,
+    trackName: track?.name || null,
     sections: allSections,
     totalQuestions,
     expectedDurationMinutes: typeConfig.expectedDurationMinutes,
@@ -206,7 +206,8 @@ export function prepareInterviewBuilderPreview({
   behaviourCount,
   grades,
 }) {
-  if (!discipline || !grade || !track) {
+  // Track is optional (null = generalist)
+  if (!discipline || !grade) {
     return {
       isValid: false,
       title: null,
@@ -224,12 +225,15 @@ export function prepareInterviewBuilderPreview({
   });
 
   if (!validCombination) {
+    const reason = track
+      ? `The ${track.name} track is not available for ${discipline.specialization}.`
+      : `${discipline.specialization} requires a track specialization.`;
     return {
       isValid: false,
       title: null,
       totalSkills: 0,
       totalBehaviours: 0,
-      invalidReason: `The ${track.name} track is not available for ${discipline.specialization}.`,
+      invalidReason: reason,
     };
   }
 
@@ -275,7 +279,8 @@ export function prepareAllInterviews({
   behaviours,
   questions,
 }) {
-  if (!discipline || !grade || !track) return null;
+  // Track is optional (null = generalist)
+  if (!discipline || !grade) return null;
 
   const job = getOrCreateJob({
     discipline,
@@ -313,8 +318,8 @@ export function prepareAllInterviews({
     disciplineId: discipline.id,
     disciplineName: discipline.specialization || discipline.name,
     gradeId: grade.id,
-    trackId: track.id,
-    trackName: track.name,
+    trackId: track?.id || null,
+    trackName: track?.name || null,
     interviews: {
       short: {
         ...shortInterview,