@forwardimpact/pathway 0.11.0 → 0.13.0

package/bin/fit-pathway.js

@@ -18,7 +18,7 @@
  *   stage [<id>]                Show stages
  *   tool [<name>]               Show tools
  *   job [<discipline> <grade>] [--track=TRACK]  Generate job definition
- *   interview <discipline> <grade> [--track=TRACK] [--type=TYPE]  Generate interview
+ *   interview <discipline> <grade> [--track=TRACK] [--type=mission|decomposition|stakeholder]  Generate interview
  *   progress <discipline> <grade> [--track=TRACK] [--compare=GRADE]  Career progression
  *   questions [options]         Browse interview questions
  *   agent [<discipline> <track>] [--output=PATH]  Generate AI agent
@@ -167,13 +167,14 @@ INTERVIEW COMMAND
 Generate interview question sets based on job requirements.
 
 Usage:
-  npx fit-pathway interview <discipline> <grade>
-  npx fit-pathway interview <d> <g> --track=<track>
-  npx fit-pathway interview <d> <g> --type=<type>
+  npx fit-pathway interview <discipline> <grade>                     All types
+  npx fit-pathway interview <d> <g> --track=<track>                  With track
+  npx fit-pathway interview <d> <g> --track=<t> --type=<type>        Single type
 
 Options:
   --track=TRACK       Track specialization
-  --type=TYPE         Interview type: full (default), short
+  --type=TYPE         Interview type: mission, decomposition, stakeholder
+                      (omit for all types)
 
 ────────────────────────────────────────────────────────────────────────────────
 PROGRESS COMMAND

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/pathway",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Career progression web app and CLI for exploring roles and generating agents",
   "license": "Apache-2.0",
   "repository": {
@@ -40,8 +40,8 @@
     "./commands": "./src/commands/index.js"
   },
   "dependencies": {
-    "@forwardimpact/schema": "^0.4.0",
-    "@forwardimpact/model": "^0.5.0",
+    "@forwardimpact/schema": "^0.6.0",
+    "@forwardimpact/model": "^0.7.0",
     "mustache": "^4.2.0",
     "simple-icons": "^16.7.0",
     "yaml": "^2.3.4"

package/src/commands/agent.js

@@ -37,7 +37,7 @@ import {
   validateAgentSkill,
   deriveReferenceGrade,
   deriveAgentSkills,
-  generateSkillMd,
+  generateSkillMarkdown,
   deriveToolkit,
   buildAgentIndex,
 } from "@forwardimpact/model";
@@ -502,7 +502,7 @@ export async function runAgentCommand({ data, args, options, dataDir }) {
   const skillFiles = derivedSkills
     .map((derived) => skillsWithAgent.find((s) => s.id === derived.skillId))
     .filter((skill) => skill?.agent)
-    .map((skill) => generateSkillMd(skill, data.stages));
+    .map((skill) => generateSkillMarkdown(skill, data.stages));
 
   // Validate all profiles
   for (const profile of profiles) {

package/src/commands/interview.js

@@ -4,9 +4,9 @@
  * Generates and displays interview questions in the terminal.
  *
  * Usage:
- *   npx pathway interview <discipline> <grade>                    # Interview for trackless job
- *   npx pathway interview <discipline> <grade> --track=<track>    # Interview with track
- *   npx pathway interview <discipline> <grade> --track=<track> --type=short
+ *   npx fit-pathway interview <discipline> <grade>                                  # All interview types
+ *   npx fit-pathway interview <discipline> <grade> --track=<track>                  # With track
+ *   npx fit-pathway interview <discipline> <grade> --track=<track> --type=mission   # Single type
  */
 
 import { createCompositeCommand } from "./command-factory.js";
@@ -16,8 +16,10 @@ import {
 } from "../formatters/interview/shared.js";
 import { interviewToMarkdown } from "../formatters/interview/markdown.js";
 
+const VALID_TYPES = Object.keys(INTERVIEW_TYPES);
+
 /**
- * Format interview output
+ * Format a single interview type as markdown
  * @param {Object} view - Presenter view
  * @param {Object} options - Options including framework
  */
@@ -25,15 +27,31 @@ function formatInterview(view, options) {
   console.log(interviewToMarkdown(view, { framework: options.framework }));
 }
 
+/**
+ * Format all interview types as markdown with separators
+ * @param {Array<Object>} views - Array of presenter views
+ * @param {Object} options - Options including framework
+ */
+function formatAllInterviews(views, options) {
+  for (let i = 0; i < views.length; i++) {
+    if (i > 0) {
+      console.log("\n" + "─".repeat(80) + "\n");
+    }
+    console.log(
+      interviewToMarkdown(views[i], { framework: options.framework }),
+    );
+  }
+}
+
 export const runInterviewCommand = createCompositeCommand({
   commandName: "interview",
   requiredArgs: ["discipline_id", "grade_id"],
   findEntities: (data, args, options) => {
-    const interviewType = options.type || "full";
+    const interviewType = options.type === "full" ? null : options.type;
 
-    if (!INTERVIEW_TYPES[interviewType]) {
+    if (interviewType && !INTERVIEW_TYPES[interviewType]) {
       console.error(`Unknown interview type: ${interviewType}`);
-      console.error("Available types: full, short, behaviour");
+      console.error(`Available types: ${VALID_TYPES.join(", ")}`);
       process.exit(1);
     }
 
@@ -58,18 +76,38 @@ export const runInterviewCommand = createCompositeCommand({
     }
     return null;
   },
-  presenter: (entities, data, _options) =>
-    prepareInterviewDetail({
+  presenter: (entities, data, _options) => {
+    const params = {
       discipline: entities.discipline,
       grade: entities.grade,
       track: entities.track,
       skills: data.skills,
       behaviours: data.behaviours,
       questions: data.questions,
-      interviewType: entities.interviewType,
-    }),
-  formatter: (view, options, data) =>
-    formatInterview(view, { ...options, framework: data.framework }),
+    };
+
+    // Single type: return one view
+    if (entities.interviewType) {
+      return prepareInterviewDetail({
+        ...params,
+        interviewType: entities.interviewType,
+      });
+    }
+
+    // All types: return array of views
+    return VALID_TYPES.map((type) =>
+      prepareInterviewDetail({ ...params, interviewType: type }),
+    ).filter(Boolean);
+  },
+  formatter: (view, options, data) => {
+    const opts = { ...options, framework: data.framework };
+
+    if (Array.isArray(view)) {
+      formatAllInterviews(view, opts);
+    } else {
+      formatInterview(view, opts);
+    }
+  },
   usageExample:
-    "npx pathway interview software_engineering L4 --track=platform --type=short",
+    "npx fit-pathway interview software_engineering J090 --track=platform --type=mission",
 });

package/src/commands/questions.js

@@ -56,12 +56,15 @@ function showQuestionsSummary(data) {
     "practitioner",
     "expert",
   ];
+  const roleTypes = ["professionalQuestions", "managementQuestions"];
   const skillRows = skillLevels.map((level) => {
     let count = 0;
     for (const skill of skills) {
-      const sq = questions.skills?.[skill.id];
-      if (sq?.[level]) {
-        count += sq[level].length;
+      const sq = questions.skillLevels?.[skill.id];
+      if (sq) {
+        for (const roleType of roleTypes) {
+          count += (sq[roleType]?.[level] || []).length;
+        }
       }
     }
     return [level, count];
@@ -81,9 +84,11 @@ function showQuestionsSummary(data) {
   const behaviourRows = maturities.map((maturity) => {
     let count = 0;
     for (const behaviour of behaviours) {
-      const bq = questions.behaviours?.[behaviour.id];
-      if (bq?.[maturity]) {
-        count += bq[maturity].length;
+      const bq = questions.behaviourMaturities?.[behaviour.id];
+      if (bq) {
+        for (const roleType of roleTypes) {
+          count += (bq[roleType]?.[maturity] || []).length;
+        }
       }
     }
     return [maturity.replace(/_/g, " "), count];
@@ -138,10 +143,8 @@ export async function runQuestionsCommand({
       behaviours: data.behaviours,
       filter,
     });
-    for (const section of view.sections) {
-      for (const q of section.questions) {
-        console.log(q.id);
-      }
+    for (const q of view.questions) {
+      console.log(q.id);
     }
     return;
   }

package/src/commands/skill.js

@@ -16,7 +16,7 @@ import { skillToMarkdown } from "../formatters/skill/markdown.js";
 import { prepareSkillsList } from "../formatters/skill/shared.js";
 import { getConceptEmoji } from "@forwardimpact/schema/levels";
 import { formatTable, formatError } from "../lib/cli-output.js";
-import { generateSkillMd } from "@forwardimpact/model/agent";
+import { generateSkillMarkdown } from "@forwardimpact/model/agent";
 import { formatAgentSkill } from "../formatters/agent/skill.js";
 import { loadSkillTemplate } from "../lib/template-loader.js";
 
@@ -80,7 +80,7 @@ async function formatAgentDetail(skill, stages, dataDir) {
   }
 
   const template = await loadSkillTemplate(dataDir);
-  const skillMd = generateSkillMd(skill, stages);
+  const skillMd = generateSkillMarkdown(skill, stages);
   const output = formatAgentSkill(skillMd, template);
   console.log(output);
 }

package/src/components/comparison-radar.js

@@ -13,7 +13,7 @@ import {
   getBehaviourMaturityIndex,
   formatLevel,
 } from "../lib/render.js";
-import { getCapabilityIndex } from "@forwardimpact/schema/levels";
+import { compareByCapability } from "@forwardimpact/model/policies";
 
 /**
  * Create a comparison skill radar chart
@@ -24,7 +24,7 @@ import { getCapabilityIndex } from "@forwardimpact/schema/levels";
  */
 export function createComparisonSkillRadar(
   currentMatrix,
-  targetMatrix,
+  targetMatrix = [],
   options = {},
 ) {
   const container = div(
@@ -80,9 +80,11 @@ export function createComparisonSkillRadar(
     }
 
     // Sort by capability order, then by skill name within capability
+    const capabilityComparator = options.capabilities
+      ? compareByCapability(options.capabilities)
+      : (a, b) => a.capability.localeCompare(b.capability);
     skillEntries.sort((a, b) => {
-      const capDiff =
-        getCapabilityIndex(a.capability) - getCapabilityIndex(b.capability);
+      const capDiff = capabilityComparator(a, b);
       if (capDiff !== 0) return capDiff;
       return a.skillName.localeCompare(b.skillName);
     });
@@ -141,7 +143,7 @@ export function createComparisonSkillRadar(
  */
 export function createComparisonBehaviourRadar(
   currentProfile,
-  targetProfile,
+  targetProfile = [],
   options = {},
 ) {
   const container = div(

package/src/css/components/badges.css

@@ -93,50 +93,60 @@
     font-weight: 500;
   }
 
-  /* Capability badges */
-  .badge-delivery {
-    background: var(--color-cat-delivery-light);
-    color: var(--color-cat-delivery);
+  /* Capability badges - each capability ID maps to its own distinct color */
+  .badge-ai {
+    background: var(--color-cap-ai-light);
+    color: var(--color-cap-ai);
   }
 
-  .badge-scale {
-    background: var(--color-cat-scale-light);
-    color: var(--color-cat-scale);
+  .badge-business {
+    background: var(--color-cap-business-light);
+    color: var(--color-cap-business);
   }
 
-  .badge-reliability {
-    background: var(--color-cat-reliability-light);
-    color: var(--color-cat-reliability);
+  .badge-data {
+    background: var(--color-cap-data-light);
+    color: var(--color-cap-data);
   }
 
-  .badge-data {
-    background: var(--color-cat-data-light);
-    color: var(--color-cat-data);
+  .badge-delivery {
+    background: var(--color-cap-delivery-light);
+    color: var(--color-cap-delivery);
   }
 
-  .badge-ai {
-    background: var(--color-cat-ai-light);
-    color: var(--color-cat-ai);
+  .badge-documentation {
+    background: var(--color-cap-documentation-light);
+    color: var(--color-cap-documentation);
+  }
+
+  .badge-ml {
+    background: var(--color-cap-ml-light);
+    color: var(--color-cap-ml);
+  }
+
+  .badge-people {
+    background: var(--color-cap-people-light);
+    color: var(--color-cap-people);
   }
 
   .badge-process {
-    background: var(--color-cat-process-light);
-    color: var(--color-cat-process);
+    background: var(--color-cap-process-light);
+    color: var(--color-cap-process);
   }
 
-  .badge-business {
-    background: var(--color-cat-business-light);
-    color: var(--color-cat-business);
+  .badge-product {
+    background: var(--color-cap-product-light);
+    color: var(--color-cap-product);
   }
 
-  .badge-people {
-    background: var(--color-cat-people-light);
-    color: var(--color-cat-people);
+  .badge-reliability {
+    background: var(--color-cap-reliability-light);
+    color: var(--color-cap-reliability);
   }
 
-  .badge-documentation {
-    background: var(--color-cat-documentation-light);
-    color: var(--color-cat-documentation);
+  .badge-scale {
+    background: var(--color-cap-scale-light);
+    color: var(--color-cap-scale);
   }
 
   /* Tool badge */

package/src/css/tokens.css

@@ -43,30 +43,34 @@
     --color-maturity-5: #c4b5fd;
 
     /* --------------------------------------------------------------------------
-     Colors - Categories (text)
+     Colors - Capabilities (text) - matches data/capabilities/*.yaml IDs
      -------------------------------------------------------------------------- */
-    --color-cat-delivery: #dc2626; /* red - rapid delivery focus */
-    --color-cat-scale: #1d4ed8; /* blue - infrastructure/platform */
-    --color-cat-reliability: #0369a1; /* sky - SRE/operations */
-    --color-cat-data: #0f766e; /* teal */
-    --color-cat-ai: #7c3aed; /* violet */
-    --color-cat-process: #c2410c; /* orange */
-    --color-cat-business: #a16207; /* amber */
-    --color-cat-people: #be185d; /* pink */
-    --color-cat-documentation: #15803d; /* green */
+    --color-cap-ai: #7c3aed; /* violet */
+    --color-cap-business: #b45309; /* amber */
+    --color-cap-data: #0f766e; /* teal */
+    --color-cap-delivery: #dc2626; /* red */
+    --color-cap-documentation: #15803d; /* green */
+    --color-cap-ml: #9333ea; /* purple */
+    --color-cap-people: #be185d; /* pink */
+    --color-cap-process: #c2410c; /* orange */
+    --color-cap-product: #4f46e5; /* indigo */
+    --color-cap-reliability: #0891b2; /* cyan */
+    --color-cap-scale: #1d4ed8; /* blue */
 
     /* --------------------------------------------------------------------------
-     Colors - Categories (backgrounds)
+     Colors - Capabilities (backgrounds)
      -------------------------------------------------------------------------- */
-    --color-cat-delivery-light: #fecaca; /* red */
-    --color-cat-scale-light: #dbeafe; /* blue */
-    --color-cat-reliability-light: #e0f2fe; /* sky */
-    --color-cat-data-light: #ccfbf1; /* teal */
-    --color-cat-ai-light: #ede9fe; /* violet */
-    --color-cat-process-light: #ffedd5; /* orange */
-    --color-cat-business-light: #fef3c7; /* amber */
-    --color-cat-people-light: #fce7f3; /* pink */
-    --color-cat-documentation-light: #dcfce7; /* green */
+    --color-cap-ai-light: #ede9fe; /* violet */
+    --color-cap-business-light: #fef3c7; /* amber */
+    --color-cap-data-light: #ccfbf1; /* teal */
+    --color-cap-delivery-light: #fecaca; /* red */
+    --color-cap-documentation-light: #dcfce7; /* green */
+    --color-cap-ml-light: #f3e8ff; /* purple */
+    --color-cap-people-light: #fce7f3; /* pink */
+    --color-cap-process-light: #ffedd5; /* orange */
+    --color-cap-product-light: #e0e7ff; /* indigo */
+    --color-cap-reliability-light: #cffafe; /* cyan */
+    --color-cap-scale-light: #dbeafe; /* blue */
 
     /* --------------------------------------------------------------------------
      Colors - Neutrals

package/src/formatters/interview/markdown.js

@@ -27,6 +27,9 @@ export function interviewToMarkdown(view, { framework } = {}) {
   // Group sections by type
   const skillSections = view.sections.filter((s) => s.type === "skill");
   const behaviourSections = view.sections.filter((s) => s.type === "behaviour");
+  const capabilitySections = view.sections.filter(
+    (s) => s.type === "capability",
+  );
 
   // Skill questions
   if (skillSections.length > 0) {
@@ -36,27 +39,83 @@ export function interviewToMarkdown(view, { framework } = {}) {
       for (const q of section.questions) {
         lines.push(`**Q**: ${q.question}`);
         if (q.followUps.length > 0) {
+          lines.push("", "**Follow-ups:**");
           for (const followUp of q.followUps) {
             lines.push(`  → ${followUp}`);
           }
         }
+        if (q.lookingFor && q.lookingFor.length > 0) {
+          lines.push("", "**What to look for:**");
+          for (const item of q.lookingFor) {
+            lines.push(`- ${item}`);
+          }
+        }
         lines.push("");
       }
     }
   }
 
-  // Behaviour questions
+  // Capability decomposition questions
+  if (capabilitySections.length > 0) {
+    lines.push(`## 🧩 Decomposition Questions`, "");
+    for (const section of capabilitySections) {
+      lines.push(`### ${section.name} (${formatLevel(section.level)})`, "");
+      for (const q of section.questions) {
+        lines.push(`**Scenario**: ${q.question}`);
+        if (q.context) {
+          lines.push(`> ${q.context}`);
+        }
+        if (q.decompositionPrompts && q.decompositionPrompts.length > 0) {
+          lines.push("", "**Guide the candidate through:**");
+          for (const prompt of q.decompositionPrompts) {
+            lines.push(`- ${prompt}`);
+          }
+        }
+        if (q.followUps.length > 0) {
+          lines.push("", "**Follow-ups:**");
+          for (const followUp of q.followUps) {
+            lines.push(`  → ${followUp}`);
+          }
+        }
+        if (q.lookingFor && q.lookingFor.length > 0) {
+          lines.push("", "**What to look for:**");
+          for (const item of q.lookingFor) {
+            lines.push(`- ${item}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  // Behaviour stakeholder simulation questions
   if (behaviourSections.length > 0) {
-    lines.push(`## ${behaviourEmoji} Behaviour Questions`, "");
+    lines.push(`## ${behaviourEmoji} Stakeholder Simulation`, "");
     for (const section of behaviourSections) {
       lines.push(`### ${section.name} (${formatLevel(section.level)})`, "");
       for (const q of section.questions) {
-        lines.push(`**Q**: ${q.question}`);
+        lines.push(`**Scenario**: ${q.question}`);
+        if (q.context) {
+          lines.push(`> ${q.context}`);
+        }
+        if (q.simulationPrompts && q.simulationPrompts.length > 0) {
+          lines.push("", "**Steer the simulation:**");
+          for (const prompt of q.simulationPrompts) {
+            lines.push(`- ${prompt}`);
+          }
+        }
         if (q.followUps.length > 0) {
+          lines.push("", "**Follow-ups:**");
           for (const followUp of q.followUps) {
             lines.push(`  → ${followUp}`);
           }
         }
+        if (q.lookingFor && q.lookingFor.length > 0) {
+          lines.push("", "**What to look for:**");
+          for (const item of q.lookingFor) {
+            lines.push(`- ${item}`);
+          }
+        }
         lines.push("");
       }
     }