@forwardimpact/pathway 0.1.0

package/app/formatters/interview/dom.js

@@ -0,0 +1,97 @@
+/**
+ * Interview formatting for DOM output
+ */
+
+import { div, heading1, heading2, p, span } from "../../lib/render.js";
+import { createBackLink } from "../../components/nav.js";
+import { createLevelDots } from "../../components/detail.js";
+import { getConceptEmoji } from "../../model/levels.js";
+
+/**
+ * Format interview detail as DOM elements
+ * @param {Object} view - Interview detail view from presenter
+ * @param {Object} typeConfig - Interview type configuration
+ * @param {Object} options - Formatting options
+ * @param {Object} [options.framework] - Framework data for emoji lookup
+ * @param {boolean} [options.showBackLink] - Whether to show back navigation link
+ * @returns {HTMLElement}
+ */
+export function interviewToDOM(
+  view,
+  typeConfig,
+  { framework, showBackLink = true } = {},
+) {
+  const skillEmoji = getConceptEmoji(framework, "skill");
+  const behaviourEmoji = getConceptEmoji(framework, "behaviour");
+  return div(
+    { className: "detail-page interview-detail" },
+    // Header
+    div(
+      { className: "page-header" },
+      showBackLink
+        ? createBackLink("/interview", "← Back to Interview Builder")
+        : null,
+      heading1({ className: "page-title" }, "💬 Interview: ", view.name),
+      p({ className: "page-description" }, view.description),
+      typeConfig
+        ? p({ className: "text-muted" }, `Type: ${typeConfig.label}`)
+        : null,
+    ),
+
+    // Questions by skill
+    view.questionsBySkill && view.questionsBySkill.length > 0
+      ? div(
+          { className: "detail-section" },
+          heading2(
+            { className: "section-title" },
+            `${skillEmoji} Skill Questions`,
+          ),
+          ...view.questionsBySkill.map((group) =>
+            div(
+              { className: "question-group" },
+              p(
+                { className: "question-group-title" },
+                span({ className: "skill-name" }, group.skillName),
+                " ",
+                createLevelDots(group.levelIndex, group.totalLevels),
+              ),
+              div(
+                { className: "question-list" },
+                ...group.questions.map((q) =>
+                  p({ className: "question-text" }, q.text),
+                ),
+              ),
+            ),
+          ),
+        )
+      : null,
+
+    // Questions by behaviour
+    view.questionsByBehaviour && view.questionsByBehaviour.length > 0
+      ? div(
+          { className: "detail-section" },
+          heading2(
+            { className: "section-title" },
+            `${behaviourEmoji} Behaviour Questions`,
+          ),
+          ...view.questionsByBehaviour.map((group) =>
+            div(
+              { className: "question-group" },
+              p(
+                { className: "question-group-title" },
+                span({ className: "behaviour-name" }, group.behaviourName),
+                " ",
+                createLevelDots(group.levelIndex, group.totalLevels),
+              ),
+              div(
+                { className: "question-list" },
+                ...group.questions.map((q) =>
+                  p({ className: "question-text" }, q.text),
+                ),
+              ),
+            ),
+          ),
+        )
+      : null,
+  );
+}

package/app/formatters/interview/markdown.js

@@ -0,0 +1,66 @@
+/**
+ * Interview formatting for markdown/CLI output
+ */
+
+import { formatLevel } from "../../lib/render.js";
+import { getConceptEmoji } from "../../model/levels.js";
+
+/**
+ * Format interview detail as markdown
+ * @param {Object} view - Interview detail view from presenter
+ * @param {Object} options - Options (e.g., type, framework)
+ * @param {Object} [options.framework] - Framework data for emoji lookup
+ * @returns {string}
+ */
+export function interviewToMarkdown(view, { framework } = {}) {
+  const skillEmoji = getConceptEmoji(framework, "skill");
+  const behaviourEmoji = getConceptEmoji(framework, "behaviour");
+  const lines = [
+    `# ${view.typeInfo.icon} Interview: ${view.title}`,
+    "",
+    `**Type**: ${view.typeInfo.name} (${view.typeInfo.description})`,
+    `**Expected duration**: ${view.expectedDurationMinutes} minutes`,
+    `**Total questions**: ${view.totalQuestions}`,
+    "",
+  ];
+
+  // Group sections by type
+  const skillSections = view.sections.filter((s) => s.type === "skill");
+  const behaviourSections = view.sections.filter((s) => s.type === "behaviour");
+
+  // Skill questions
+  if (skillSections.length > 0) {
+    lines.push(`## ${skillEmoji} Skill Questions`, "");
+    for (const section of skillSections) {
+      lines.push(`### ${section.name} (${formatLevel(section.level)})`, "");
+      for (const q of section.questions) {
+        lines.push(`**Q**: ${q.question}`);
+        if (q.followUps.length > 0) {
+          for (const followUp of q.followUps) {
+            lines.push(`  → ${followUp}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  // Behaviour questions
+  if (behaviourSections.length > 0) {
+    lines.push(`## ${behaviourEmoji} Behaviour Questions`, "");
+    for (const section of behaviourSections) {
+      lines.push(`### ${section.name} (${formatLevel(section.level)})`, "");
+      for (const q of section.questions) {
+        lines.push(`**Q**: ${q.question}`);
+        if (q.followUps.length > 0) {
+          for (const followUp of q.followUps) {
+            lines.push(`  → ${followUp}`);
+          }
+        }
+        lines.push("");
+      }
+    }
+  }
+
+  return lines.join("\n");
+}

package/app/formatters/interview/shared.js

@@ -0,0 +1,332 @@
+/**
+ * Interview presentation helpers
+ *
+ * Shared utilities for formatting interview data across DOM and markdown outputs.
+ */
+
+import {
+  isValidJobCombination,
+  generateJobTitle,
+  getDisciplineSkillIds,
+} from "../../model/derivation.js";
+import {
+  deriveInterviewQuestions,
+  deriveShortInterview,
+  deriveBehaviourQuestions,
+} from "../../model/interview.js";
+import { getOrCreateJob } from "../../lib/job-cache.js";
+
+/**
+ * Interview type configurations
+ */
+export const INTERVIEW_TYPES = {
+  short: {
+    id: "short",
+    name: "Screening",
+    description: "20-minute screening interview",
+    icon: "⏱️",
+    expectedDurationMinutes: 20,
+  },
+  behaviour: {
+    id: "behaviour",
+    name: "Behavioural",
+    description: "Focus on behaviours and mindsets",
+    icon: "🧠",
+    expectedDurationMinutes: 45,
+  },
+  full: {
+    id: "full",
+    name: "Full Interview",
+    description: "Comprehensive interview covering all skills and behaviours",
+    icon: "📋",
+    expectedDurationMinutes: 90,
+  },
+};
+
+/**
+ * Transform raw interview questions into sections
+ * @param {Array} questions - Raw questions from interview module
+ * @returns {Array}
+ */
+function groupQuestionsIntoSections(questions) {
+  const sections = {};
+
+  for (const q of questions) {
+    const id = q.targetId;
+    const name = q.targetName;
+    const type = q.targetType;
+    const level = q.targetLevel;
+
+    if (!sections[id]) {
+      sections[id] = {
+        id,
+        name,
+        type,
+        level,
+        questions: [],
+      };
+    }
+
+    sections[id].questions.push({
+      skillOrBehaviourId: id,
+      skillOrBehaviourName: name,
+      type,
+      level,
+      question: q.question.text,
+      followUps: q.question.followUps || [],
+    });
+  }
+
+  return Object.values(sections);
+}
+
+/**
+ * @typedef {Object} InterviewDetailView
+ * @property {string} title
+ * @property {string} interviewType - 'full', 'short', or 'behaviour'
+ * @property {string} disciplineId
+ * @property {string} disciplineName
+ * @property {string} gradeId
+ * @property {string} trackId
+ * @property {string} trackName
+ * @property {Array} sections
+ * @property {number} totalQuestions
+ * @property {number} expectedDurationMinutes
+ * @property {Object} typeInfo
+ */
+
+/**
+ * Prepare interview questions for a job
+ * @param {Object} params
+ * @param {Object} params.discipline
+ * @param {Object} params.grade
+ * @param {Object} params.track
+ * @param {Array} params.skills
+ * @param {Array} params.behaviours
+ * @param {Array} params.questions
+ * @param {string} [params.interviewType='full']
+ * @returns {InterviewDetailView|null}
+ */
+export function prepareInterviewDetail({
+  discipline,
+  grade,
+  track,
+  skills,
+  behaviours,
+  questions,
+  interviewType = "full",
+}) {
+  if (!discipline || !grade || !track) return null;
+
+  const job = getOrCreateJob({
+    discipline,
+    grade,
+    track,
+    skills,
+    behaviours,
+  });
+
+  if (!job) return null;
+
+  let interviewGuide;
+  switch (interviewType) {
+    case "short":
+      interviewGuide = deriveShortInterview({ job, questionBank: questions });
+      break;
+    case "behaviour":
+      interviewGuide = deriveBehaviourQuestions({
+        job,
+        questionBank: questions,
+      });
+      break;
+    case "full":
+    default:
+      interviewGuide = deriveInterviewQuestions({
+        job,
+        questionBank: questions,
+      });
+      break;
+  }
+
+  // Extract the questions array from the interview guide
+  const rawQuestions = interviewGuide.questions || [];
+
+  // Separate skill and behaviour questions based on targetType
+  const skillQuestions = rawQuestions.filter((q) => q.targetType === "skill");
+  const behaviourQuestions = rawQuestions.filter(
+    (q) => q.targetType === "behaviour",
+  );
+
+  const skillSections = groupQuestionsIntoSections(skillQuestions);
+  const behaviourSections = groupQuestionsIntoSections(behaviourQuestions);
+
+  const allSections = [...skillSections, ...behaviourSections];
+  const totalQuestions = rawQuestions.length;
+
+  const typeConfig = INTERVIEW_TYPES[interviewType] || INTERVIEW_TYPES.full;
+
+  return {
+    title: job.title,
+    interviewType,
+    disciplineId: discipline.id,
+    disciplineName: discipline.specialization || discipline.name,
+    gradeId: grade.id,
+    trackId: track.id,
+    trackName: track.name,
+    sections: allSections,
+    totalQuestions,
+    expectedDurationMinutes: typeConfig.expectedDurationMinutes,
+    typeInfo: typeConfig,
+  };
+}
+
+/**
+ * @typedef {Object} InterviewBuilderPreview
+ * @property {boolean} isValid
+ * @property {string|null} title
+ * @property {number} totalSkills
+ * @property {number} totalBehaviours
+ * @property {string|null} invalidReason
+ */
+
+/**
+ * Prepare interview builder preview for form validation
+ * @param {Object} params
+ * @param {Object|null} params.discipline
+ * @param {Object|null} params.grade
+ * @param {Object|null} params.track
+ * @param {number} params.behaviourCount - Total behaviours in the system
+ * @param {Array} [params.grades] - All grades for validation
+ * @returns {InterviewBuilderPreview}
+ */
+export function prepareInterviewBuilderPreview({
+  discipline,
+  grade,
+  track,
+  behaviourCount,
+  grades,
+}) {
+  if (!discipline || !grade || !track) {
+    return {
+      isValid: false,
+      title: null,
+      totalSkills: 0,
+      totalBehaviours: 0,
+      invalidReason: null,
+    };
+  }
+
+  const validCombination = isValidJobCombination({
+    discipline,
+    grade,
+    track,
+    grades,
+  });
+
+  if (!validCombination) {
+    return {
+      isValid: false,
+      title: null,
+      totalSkills: 0,
+      totalBehaviours: 0,
+      invalidReason: `The ${track.name} track is not available for ${discipline.specialization}.`,
+    };
+  }
+
+  const title = generateJobTitle(discipline, grade, track);
+  const totalSkills = getDisciplineSkillIds(discipline).length;
+
+  return {
+    isValid: true,
+    title: `Interview for: ${title}`,
+    totalSkills,
+    totalBehaviours: behaviourCount,
+    invalidReason: null,
+  };
+}
+
+/**
+ * @typedef {Object} AllInterviewsView
+ * @property {string} title
+ * @property {string} disciplineId
+ * @property {string} disciplineName
+ * @property {string} gradeId
+ * @property {string} trackId
+ * @property {string} trackName
+ * @property {Object.<string, Object>} interviews - Keyed by type
+ */
+
+/**
+ * Prepare all interview types for a job (for toggle UI)
+ * @param {Object} params
+ * @param {Object} params.discipline
+ * @param {Object} params.grade
+ * @param {Object} params.track
+ * @param {Array} params.skills
+ * @param {Array} params.behaviours
+ * @param {Array} params.questions
+ * @returns {AllInterviewsView|null}
+ */
+export function prepareAllInterviews({
+  discipline,
+  grade,
+  track,
+  skills,
+  behaviours,
+  questions,
+}) {
+  if (!discipline || !grade || !track) return null;
+
+  const job = getOrCreateJob({
+    discipline,
+    grade,
+    track,
+    skills,
+    behaviours,
+  });
+
+  if (!job) return null;
+
+  // Generate all interview types
+  const shortInterview = deriveShortInterview({
+    job,
+    questionBank: questions,
+    targetMinutes: 20,
+  });
+
+  const behaviourInterview = deriveBehaviourQuestions({
+    job,
+    questionBank: questions,
+  });
+
+  const fullInterview = deriveInterviewQuestions({
+    job,
+    questionBank: questions,
+    options: {
+      targetMinutes: 60,
+      skillBehaviourRatio: 0.6,
+    },
+  });
+
+  return {
+    title: job.title,
+    disciplineId: discipline.id,
+    disciplineName: discipline.specialization || discipline.name,
+    gradeId: grade.id,
+    trackId: track.id,
+    trackName: track.name,
+    interviews: {
+      short: {
+        ...shortInterview,
+        type: "short",
+        typeInfo: INTERVIEW_TYPES.short,
+      },
+      behaviour: {
+        ...behaviourInterview,
+        type: "behaviour",
+        typeInfo: INTERVIEW_TYPES.behaviour,
+      },
+      full: { ...fullInterview, type: "full", typeInfo: INTERVIEW_TYPES.full },
+    },
+  };
+}

package/app/formatters/job/description.js

@@ -0,0 +1,176 @@
+/**
+ * Job Description Formatter
+ *
+ * Formats job data into markdown job description content.
+ * Parallels formatters/agent/profile.js in structure.
+ */
+
+import {
+  SKILL_LEVEL_ORDER,
+  BEHAVIOUR_MATURITY_ORDER,
+} from "../../model/levels.js";
+
+/**
+ * Format job as a markdown job description
+ * @param {Object} params
+ * @param {Object} params.job - The job definition
+ * @param {Object} params.discipline - The discipline
+ * @param {Object} params.grade - The grade
+ * @param {Object} params.track - The track
+ * @returns {string} Markdown formatted job description
+ */
+export function formatJobDescription({ job, discipline, grade, track }) {
+  const lines = [];
+
+  // Title
+  lines.push(`# ${job.title}`);
+  lines.push("");
+
+  // Meta information
+  lines.push(`- **Level:** ${grade.id}`);
+  lines.push(`- **Experience:** ${grade.typicalExperienceRange}`);
+  lines.push(`- **Track:** ${track.name}`);
+  lines.push("");
+
+  // Role Summary
+  lines.push("## ROLE SUMMARY");
+  lines.push("");
+
+  // Build role summary from discipline - use manager version if applicable
+  const isManagement = track.isManagement === true;
+  let roleSummary =
+    isManagement && discipline.managementRoleSummary
+      ? discipline.managementRoleSummary
+      : discipline.professionalRoleSummary || discipline.description;
+  // Replace placeholders
+  const { roleTitle, specialization } = discipline;
+  roleSummary = roleSummary.replace(/\{roleTitle\}/g, roleTitle);
+  roleSummary = roleSummary.replace(/\{specialization\}/g, specialization);
+  lines.push(roleSummary);
+  lines.push("");
+
+  // Add track context
+  if (track.roleContext) {
+    lines.push(track.roleContext);
+    lines.push("");
+  }
+
+  // Add grade expectations as natural paragraphs
+  if (job.expectations) {
+    const exp = job.expectations;
+    const expectationSentences = [];
+
+    if (exp.impactScope) {
+      expectationSentences.push(
+        `This role encompasses ${exp.impactScope.toLowerCase()}.`,
+      );
+    }
+    if (exp.autonomyExpectation) {
+      let autonomySentence = `You will ${exp.autonomyExpectation.toLowerCase()}`;
+      if (exp.influenceScope) {
+        autonomySentence +=
+          `, ${exp.influenceScope.toLowerCase()}` +
+          (exp.influenceScope.endsWith(".") ? "" : ".");
+      } else {
+        autonomySentence += exp.autonomyExpectation.endsWith(".") ? "" : ".";
+      }
+      expectationSentences.push(autonomySentence);
+    } else if (exp.influenceScope) {
+      expectationSentences.push(
+        exp.influenceScope + (exp.influenceScope.endsWith(".") ? "" : "."),
+      );
+    }
+    if (exp.complexityHandled) {
+      expectationSentences.push(
+        `You will handle ${exp.complexityHandled.toLowerCase()}.`,
+      );
+    }
+
+    if (expectationSentences.length > 0) {
+      lines.push(expectationSentences.join(" "));
+      lines.push("");
+    }
+  }
+
+  // Key Responsibilities
+  lines.push("## ROLE RESPONSIBILITIES");
+  lines.push("");
+
+  // Use derived responsibilities (already sorted by level descending)
+  const derivedResponsibilities = job.derivedResponsibilities || [];
+
+  for (const r of derivedResponsibilities) {
+    lines.push(`- **${r.capabilityName}:** ${r.responsibility}`);
+  }
+  lines.push("");
+
+  // Key Behaviours
+  lines.push("## ROLE BEHAVIOURS");
+  lines.push("");
+
+  // Sort behaviours by maturity level (highest first)
+  const sortedBehaviours = [...job.behaviourProfile].sort((a, b) => {
+    const indexA = BEHAVIOUR_MATURITY_ORDER.indexOf(a.maturity);
+    const indexB = BEHAVIOUR_MATURITY_ORDER.indexOf(b.maturity);
+    // Sort in reverse order (exemplifying first, emerging last)
+    if (indexA === -1 && indexB === -1) return 0;
+    if (indexA === -1) return 1;
+    if (indexB === -1) return -1;
+    return indexB - indexA;
+  });
+
+  for (const behaviour of sortedBehaviours) {
+    lines.push(
+      `- **${behaviour.behaviourName}:** ${behaviour.maturityDescription || ""}`,
+    );
+  }
+  lines.push("");
+
+  // Group skills by level
+  const skillsByLevel = {};
+  for (const skill of job.skillMatrix) {
+    const level = skill.level || "Other";
+    if (!skillsByLevel[level]) {
+      skillsByLevel[level] = [];
+    }
+    skillsByLevel[level].push(skill);
+  }
+
+  // Sort levels in a logical order using SKILL_LEVEL_ORDER from types.js
+  const sortedLevels = Object.keys(skillsByLevel).sort((a, b) => {
+    const indexA = SKILL_LEVEL_ORDER.indexOf(a.toLowerCase());
+    const indexB = SKILL_LEVEL_ORDER.indexOf(b.toLowerCase());
+    // Sort in reverse order (expert first, awareness last)
+    if (indexA === -1 && indexB === -1) return a.localeCompare(b);
+    if (indexA === -1) return 1;
+    if (indexB === -1) return -1;
+    return indexB - indexA;
+  });
+
+  for (const level of sortedLevels) {
+    const skills = skillsByLevel[level];
+    if (skills.length > 0) {
+      lines.push(`## ${level.toUpperCase()}-LEVEL SKILLS`);
+      lines.push("");
+      // Sort skills alphabetically by name
+      const sortedSkills = [...skills].sort((a, b) =>
+        (a.skillName || "").localeCompare(b.skillName || ""),
+      );
+      for (const skill of sortedSkills) {
+        lines.push(`- **${skill.skillName}:** ${skill.levelDescription || ""}`);
+      }
+      lines.push("");
+    }
+  }
+
+  // Qualifications
+  lines.push("## QUALIFICATIONS");
+  lines.push("");
+
+  if (grade.qualificationSummary) {
+    lines.push(grade.qualificationSummary);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}