@forwardimpact/pathway 0.1.0 → 0.2.0

package/app/formatters/skill/microdata.js

@@ -0,0 +1,151 @@
+/**
+ * Skill formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with capability.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  propRaw,
+  metaTag,
+  section,
+  dl,
+  ul,
+  escapeHtml,
+  formatLevelName,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareSkillsList, prepareSkillDetail } from "./shared.js";
+
+/**
+ * Format skill list as microdata HTML
+ * @param {Array} skills - Raw skill entities
+ * @param {Array} capabilities - Capability entities
+ * @returns {string} HTML with microdata
+ */
+export function skillListToMicrodata(skills, capabilities) {
+  const { groups, groupOrder } = prepareSkillsList(skills, capabilities);
+
+  const content = groupOrder
+    .map((capability) => {
+      const capabilitySkills = groups[capability];
+      const skillItems = capabilitySkills
+        .map(
+          (
+            skill,
+          ) => `${openTag("article", { itemtype: "Skill", itemid: `#${skill.id}` })}
+${prop("h3", "name", skill.name)}
+${prop("p", "description", skill.truncatedDescription)}
+${metaTag("capability", capability)}
+</article>`,
+        )
+        .join("\n");
+
+      return section(formatLevelName(capability), skillItems, 2);
+    })
+    .join("\n");
+
+  return htmlDocument(
+    "Skills",
+    `<main>
+<h1>Skills</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format skill detail as microdata HTML
+ * @param {Object} skill - Raw skill entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.disciplines - All disciplines
+ * @param {Array} context.tracks - All tracks
+ * @param {Array} context.drivers - All drivers
+ * @param {Array} context.capabilities - Capability entities
+ * @returns {string} HTML with microdata
+ */
+export function skillToMicrodata(
+  skill,
+  { disciplines, tracks, drivers, capabilities },
+) {
+  const view = prepareSkillDetail(skill, {
+    disciplines,
+    tracks,
+    drivers,
+    capabilities,
+  });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Human-only badge
+  if (view.isHumanOnly) {
+    sections.push(`<p><strong>Human-Only</strong> — Requires interpersonal skills; excluded from agents</p>
+${metaTag("isHumanOnly", "true")}`);
+  }
+
+  // Level descriptions - uses LevelDescriptions itemtype
+  const levelPairs = Object.entries(view.levelDescriptions).map(
+    ([level, desc]) => ({
+      term: formatLevelName(level),
+      definition: desc,
+      itemprop: `${level}Description`,
+    }),
+  );
+  sections.push(
+    section(
+      "Level Descriptions",
+      `${openTag("div", { itemtype: "LevelDescriptions", itemprop: "levelDescriptions" })}
+${dl(levelPairs)}
+</div>`,
+      2,
+    ),
+  );
+
+  // Related disciplines
+  if (view.relatedDisciplines.length > 0) {
+    const disciplineItems = view.relatedDisciplines.map(
+      (d) =>
+        `<a href="#${escapeHtml(d.id)}">${escapeHtml(d.name)}</a> (${escapeHtml(d.skillType)})`,
+    );
+    sections.push(section("Used in Disciplines", ul(disciplineItems), 2));
+  }
+
+  // Related tracks with modifiers
+  if (view.relatedTracks.length > 0) {
+    const trackItems = view.relatedTracks.map((t) => {
+      const modifierStr = t.modifier > 0 ? `+${t.modifier}` : `${t.modifier}`;
+      return `<a href="#${escapeHtml(t.id)}">${escapeHtml(t.name)}</a>: ${modifierStr}`;
+    });
+    sections.push(section("Modified by Tracks", ul(trackItems), 2));
+  }
+
+  // Related drivers
+  if (view.relatedDrivers.length > 0) {
+    const driverItems = view.relatedDrivers.map(
+      (d) => `<a href="#${escapeHtml(d.id)}">${escapeHtml(d.name)}</a>`,
+    );
+    sections.push(section("Linked to Drivers", ul(driverItems), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Skill", itemid: `#${view.id}` })}
+${prop("h1", "name", view.name)}
+${metaTag("id", view.id)}
+${metaTag("capability", view.capability)}
+${propRaw(
+  "div",
+  "human",
+  `${openTag("div", { itemtype: "SkillHumanSection" })}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</div>`,
+)}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/stage/dom.js

@@ -5,6 +5,7 @@
 import { div, h2, p, a, span, ul, li } from "../../lib/render.js";
 import { createBackLink } from "../../components/nav.js";
 import { prepareStageDetail, getStageEmoji } from "./shared.js";
+import { createJsonLdScript, stageToJsonLd } from "../json-ld.js";
 
 /**
  * Format stage detail as DOM elements
@@ -20,6 +21,8 @@ export function stageToDOM(stage, { stages = [], showBackLink = true } = {}) {
 
   return div(
     { className: "detail-page stage-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(stageToJsonLd(stage)),
     // Header
     div(
       { className: "page-header" },
@@ -27,28 +30,10 @@ export function stageToDOM(stage, { stages = [], showBackLink = true } = {}) {
       div(
         { className: "page-title-row" },
         span({ className: "page-title" }, `${emoji} ${view.name}`),
-        span({ className: `badge ${view.modeClassName}` }, view.modeBadge),
       ),
       p({ className: "page-description" }, view.description),
     ),
 
-    // Tools section
-    view.tools.length > 0
-      ? div(
-          { className: "section section-detail" },
-          h2({ className: "section-title" }, "Available Tools"),
-          div(
-            { className: "tool-badges" },
-            ...view.tools.map((tool) =>
-              span(
-                { className: "badge badge-tool", title: tool.label },
-                `${tool.icon} ${tool.label}`,
-              ),
-            ),
-          ),
-        )
-      : null,
-
     // Entry/Exit Criteria
     view.entryCriteria.length > 0 || view.exitCriteria.length > 0
       ? div(

package/app/formatters/stage/microdata.js

@@ -0,0 +1,110 @@
+/**
+ * Stage formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with stages.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  linkTag,
+  section,
+  ul,
+  escapeHtml,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareStagesList, prepareStageDetail } from "./shared.js";
+
+/**
+ * Format stage list as microdata HTML
+ * @param {Array} stages - Raw stage entities
+ * @returns {string} HTML with microdata
+ */
+export function stageListToMicrodata(stages) {
+  const { items } = prepareStagesList(stages);
+
+  const content = items
+    .map((stage) => {
+      const handoffText =
+        stage.handoffs.length > 0
+          ? `→ ${stage.handoffs.map((h) => h.target).join(", ")}`
+          : "";
+      return `${openTag("article", { itemtype: "Stage", itemid: `#${stage.id}` })}
+${prop("h2", "name", `${stage.emoji || ""} ${stage.name}`)}
+${prop("p", "description", stage.truncatedDescription)}
+${handoffText ? `<p>Handoffs: ${handoffText}</p>` : ""}
+</article>`;
+    })
+    .join("\n");
+
+  return htmlDocument(
+    "Stages",
+    `<main>
+<h1>Stages</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format stage detail as microdata HTML
+ * @param {Object} stage - Raw stage entity
+ * @returns {string} HTML with microdata
+ */
+export function stageToMicrodata(stage) {
+  const view = prepareStageDetail(stage);
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Entry criteria
+  if (view.entryCriteria.length > 0) {
+    const criteriaItems = view.entryCriteria.map((c) => escapeHtml(c));
+    sections.push(
+      section("Entry Criteria", ul(criteriaItems, "entryCriteria"), 2),
+    );
+  }
+
+  // Constraints
+  if (view.constraints.length > 0) {
+    const constraintItems = view.constraints.map((c) => escapeHtml(c));
+    sections.push(
+      section("Constraints", ul(constraintItems, "constraints"), 2),
+    );
+  }
+
+  // Exit criteria
+  if (view.exitCriteria.length > 0) {
+    const exitItems = view.exitCriteria.map((c) => escapeHtml(c));
+    sections.push(section("Exit Criteria", ul(exitItems, "exitCriteria"), 2));
+  }
+
+  // Handoffs - using Handoff itemtype
+  if (view.handoffs.length > 0) {
+    const handoffItems = view.handoffs.map(
+      (
+        h,
+      ) => `${openTag("article", { itemtype: "Handoff", itemprop: "handoffs" })}
+${linkTag("targetStage", `#${h.target}`)}
+<p><strong>${prop("span", "label", h.label)}</strong> → ${escapeHtml(h.target)}</p>
+${prop("p", "prompt", h.prompt)}
+</article>`,
+    );
+    sections.push(section("Handoffs", handoffItems.join("\n"), 2));
+  }
+
+  const body = `<main>
+${openTag("article", { itemtype: "Stage", itemid: `#${view.id}` })}
+${prop("h1", "name", view.name)}
+${metaTag("id", view.id)}
+${stage.emoji ? metaTag("emoji", stage.emoji) : ""}
+${prop("p", "description", view.description)}
+${sections.join("\n")}
+</article>
+</main>`;
+
+  return htmlDocument(view.name, body);
+}

package/app/formatters/stage/shared.js

@@ -6,19 +6,6 @@
 
 import { truncate } from "../shared.js";
 
-/**
- * Tool display configuration
- * @type {Object<string, {icon: string, label: string}>}
- */
-const TOOL_CONFIG = {
-  search: { icon: "🔍", label: "Search" },
-  fetch: { icon: "🌐", label: "Fetch" },
-  codebase: { icon: "📂", label: "Codebase" },
-  read: { icon: "📖", label: "Read" },
-  edit: { icon: "✏️", label: "Edit" },
-  terminal: { icon: "💻", label: "Terminal" },
-};
-
 /**
  * @typedef {Object} StageListItem
  * @property {string} id
@@ -26,7 +13,6 @@ const TOOL_CONFIG = {
  * @property {string} emoji
  * @property {string} description
  * @property {string} truncatedDescription
- * @property {Array<{id: string, icon: string, label: string}>} tools
  * @property {Array<{target: string, label: string}>} handoffs
  */
 
@@ -38,18 +24,12 @@ const TOOL_CONFIG = {
  */
 export function prepareStagesList(stages, descriptionLimit = 150) {
   const items = stages.map((stage) => {
-    const tools = stage.availableTools || [];
     return {
       id: stage.id,
       name: stage.name,
       emoji: stage.emoji,
       description: stage.description,
       truncatedDescription: truncate(stage.description, descriptionLimit),
-      tools: tools.map((toolId) => ({
-        id: toolId,
-        icon: TOOL_CONFIG[toolId]?.icon || "🔧",
-        label: TOOL_CONFIG[toolId]?.label || toolId,
-      })),
       handoffs: (stage.handoffs || []).map((h) => ({
         target: h.targetStage,
         label: h.label,
@@ -65,7 +45,6 @@ export function prepareStagesList(stages, descriptionLimit = 150) {
  * @property {string} id
  * @property {string} name
  * @property {string} description
- * @property {Array<{id: string, icon: string, label: string}>} tools
  * @property {string[]} constraints
  * @property {string[]} entryCriteria
  * @property {string[]} exitCriteria
@@ -78,16 +57,10 @@ export function prepareStagesList(stages, descriptionLimit = 150) {
  * @returns {StageDetailView}
  */
 export function prepareStageDetail(stage) {
-  const tools = stage.availableTools || [];
   return {
     id: stage.id,
     name: stage.name,
     description: stage.description,
-    tools: tools.map((toolId) => ({
-      id: toolId,
-      icon: TOOL_CONFIG[toolId]?.icon || "🔧",
-      label: TOOL_CONFIG[toolId]?.label || toolId,
-    })),
     constraints: stage.constraints || [],
     entryCriteria: stage.entryCriteria || [],
     exitCriteria: stage.exitCriteria || [],

package/app/formatters/track/dom.js

@@ -4,12 +4,9 @@
 
 import { div, h1, p } from "../../lib/render.js";
 import { createBackLink } from "../../components/nav.js";
-import { createBadge, createStatCard } from "../../components/card.js";
+import { createStatCard } from "../../components/card.js";
 import { createStatsGrid } from "../../components/grid.js";
-import {
-  createDetailSection,
-  createLinksList,
-} from "../../components/detail.js";
+import { createDetailSection } from "../../components/detail.js";
 import {
   createJobBuilderButton,
   createInterviewPrepButton,
@@ -20,22 +17,7 @@ import {
 } from "../../components/modifier-table.js";
 import { getConceptEmoji } from "../../model/levels.js";
 import { prepareTrackDetail } from "./shared.js";
-
-/**
- * Get track type badge(s)
- * @param {Object} view
- * @returns {HTMLElement[]}
- */
-function getTrackTypeBadges(view) {
-  const badges = [];
-  if (view.isProfessional) {
-    badges.push(createBadge("Professional", "secondary"));
-  }
-  if (view.isManagement) {
-    badges.push(createBadge("Management", "default"));
-  }
-  return badges;
-}
+import { createJsonLdScript, trackToJsonLd } from "../json-ld.js";
 
 /**
  * Format track detail as DOM elements
@@ -80,12 +62,13 @@ export function trackToDOM(
 
   return div(
     { className: "detail-page track-detail" },
+    // JSON-LD structured data
+    createJsonLdScript(trackToJsonLd(track)),
     // Header
     div(
       { className: "page-header" },
       createBackLink("/track", "← Back to Tracks"),
       h1({ className: "page-title" }, `${emoji} `, view.name),
-      div({ className: "page-meta" }, ...getTrackTypeBadges(view)),
       p(
         { className: "text-muted", style: "margin-top: 0.5rem" },
         view.description,
@@ -97,14 +80,6 @@ export function trackToDOM(
       ),
     ),
 
-    // Valid disciplines (if restricted)
-    view.validDisciplines.length > 0
-      ? createDetailSection({
-          title: "Valid Disciplines",
-          content: createLinksList(view.validDisciplines, "/discipline"),
-        })
-      : null,
-
     // Matching weights (stat cards)
     track.matchingWeights
       ? createDetailSection({

package/app/formatters/track/markdown.js

@@ -18,10 +18,7 @@ export function trackListToMarkdown(tracks, framework) {
   const lines = [`# ${emoji} Tracks`, ""];
 
   for (const track of items) {
-    const types = [];
-    if (track.isProfessional) types.push("Professional");
-    if (track.isManagement) types.push("Management");
-    lines.push(`- **${track.name}**: ${types.join(", ")}`);
+    lines.push(`- **${track.name}**`);
   }
   lines.push("");
 
@@ -44,19 +41,8 @@ export function trackToMarkdown(
 ) {
   const view = prepareTrackDetail(track, { skills, behaviours, disciplines });
 
-  const types = [];
-  if (view.isProfessional) types.push("Professional");
-  if (view.isManagement) types.push("Management");
-
   const emoji = framework ? getConceptEmoji(framework, "track") : "🛤️";
-  const lines = [
-    `# ${emoji} ${view.name}`,
-    "",
-    `**Type**: ${types.join(", ")}`,
-    "",
-    view.description,
-    "",
-  ];
+  const lines = [`# ${emoji} ${view.name}`, "", view.description, ""];
 
   // Skill modifiers - show expanded skills for capabilities
   if (view.skillModifiers.length > 0) {
@@ -92,14 +78,5 @@ export function trackToMarkdown(
     lines.push("");
   }
 
-  // Valid disciplines
-  if (view.validDisciplines.length > 0) {
-    lines.push("## Valid Disciplines", "");
-    for (const d of view.validDisciplines) {
-      lines.push(`- ${d.name}`);
-    }
-    lines.push("");
-  }
-
   return lines.join("\n");
 }

package/app/formatters/track/microdata.js

@@ -0,0 +1,111 @@
+/**
+ * Track formatting for microdata HTML output
+ *
+ * Generates clean, class-less HTML with microdata aligned with track.schema.json
+ * RDF vocab: https://schema.forwardimpact.team/rdf/
+ */
+
+import {
+  openTag,
+  prop,
+  metaTag,
+  linkTag,
+  section,
+  ul,
+  escapeHtml,
+  htmlDocument,
+} from "../microdata-shared.js";
+import { prepareTracksList, prepareTrackDetail } from "./shared.js";
+
+/**
+ * Format track list as microdata HTML
+ * @param {Array} tracks - Raw track entities
+ * @returns {string} HTML with microdata
+ */
+export function trackListToMicrodata(tracks) {
+  const { items } = prepareTracksList(tracks);
+
+  const content = items
+    .map((track) => {
+      return `${openTag("article", { itemtype: "Track", itemid: `#${track.id}` })}
+${prop("h2", "name", track.name)}
+</article>`;
+    })
+    .join("\n");
+
+  return htmlDocument(
+    "Tracks",
+    `<main>
+<h1>Tracks</h1>
+${content}
+</main>`,
+  );
+}
+
+/**
+ * Format track detail as microdata HTML
+ * @param {Object} track - Raw track entity
+ * @param {Object} context - Additional context
+ * @param {Array} context.skills - All skills
+ * @param {Array} context.behaviours - All behaviours
+ * @param {Array} context.disciplines - All disciplines
+ * @returns {string} HTML with microdata
+ */
+export function trackToMicrodata(track, { skills, behaviours, disciplines }) {
+  const view = prepareTrackDetail(track, { skills, behaviours, disciplines });
+
+  if (!view) return "";
+
+  const sections = [];
+
+  // Skill modifiers - using SkillModifier itemtype with targetCapability
+  if (view.skillModifiers.length > 0) {
+    const modifierItems = view.skillModifiers.map((m) => {
+      const modifierStr = m.modifier > 0 ? `+${m.modifier}` : `${m.modifier}`;
+
+      if (m.isCapability && m.skills && m.skills.length > 0) {
+        // Capability with expanded skills
+        const skillLinks = m.skills
+          .map(
+            (s) => `<a href="#${escapeHtml(s.id)}">${escapeHtml(s.name)}</a>`,
+          )
+          .join(", ");
+        return `${openTag("div", { itemtype: "SkillModifier", itemprop: "skillModifiers" })}
+${linkTag("targetCapability", `#${m.id}`)}
+<strong>${escapeHtml(m.name)} Capability</strong> (${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>)
+<p>${skillLinks}</p>
+</div>`;
+      } else {
+        // Individual skill or capability without skills
+        return `${openTag("span", { itemtype: "SkillModifier", itemprop: "skillModifiers" })}
+${linkTag("targetCapability", `#${m.id}`)}
+<strong>${escapeHtml(m.name)}</strong>: ${openTag("span", { itemprop: "modifierValue" })}${modifierStr}</span>
+</span>`;
+      }
+    });
+    sections.push(section("Skill Modifiers", modifierItems.join("\n"), 2));
+  }
+
+  // Behaviour modifiers - using BehaviourModifier itemtype
+  if (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: "Track", 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);
+}