@forwardimpact/libsyntheticrender 0.1.1

package/render/link-assigner.js

@@ -0,0 +1,350 @@
+/**
+ * Link Assigner — deterministic cross-link assignment between entities.
+ *
+ * Assigns drugs to projects, platforms to projects, people to events/courses,
+ * and builds all cross-entity relationships using seeded random for
+ * reproducibility.
+ *
+ * @module libuniverse/render/link-assigner
+ */
+
+import { createSeededRNG } from "@forwardimpact/libsyntheticgen/rng";
+
+/**
+ * @typedef {object} LinkedEntities
+ * @property {object[]} drugs
+ * @property {object[]} platforms
+ * @property {object[]} projects - enriched with drug/platform/people links
+ * @property {object[]} courses - enriched with prereqs, attendees, platform/drug links
+ * @property {object[]} events - enriched with organizer, attendees, about links
+ * @property {object[]} blogPosts - enriched with author, about, mentions
+ */
+
+/**
+ * Assign cross-links between all entity types deterministically.
+ * @param {object} params
+ * @param {object[]} params.drugs
+ * @param {object[]} params.platforms
+ * @param {object[]} params.projects
+ * @param {object[]} params.people
+ * @param {object[]} params.teams
+ * @param {object[]} params.departments
+ * @param {string} params.domain
+ * @param {number} params.courseCount
+ * @param {number} params.eventCount
+ * @param {number} params.blogCount
+ * @param {string[]} [params.articleTopics=[]]
+ * @param {number} [params.seed=42]
+ * @returns {LinkedEntities}
+ */
+export function assignLinks({
+  drugs,
+  platforms,
+  projects,
+  people,
+  teams,
+  departments,
+  domain,
+  courseCount,
+  eventCount,
+  blogCount,
+  articleTopics = [],
+  seed = 42,
+}) {
+  const rng = createSeededRNG(seed + 1000);
+  const base = `https://${domain}`;
+
+  // --- Project linking ---
+  const linkedProjects = projects.map((proj) => {
+    const projectTeams = teams.filter((t) => proj.teams.includes(t.id));
+    const projectPeople = people.filter((p) =>
+      projectTeams.some((t) => t.id === p.team_id),
+    );
+    const leader =
+      projectPeople.find((p) => p.is_manager) || rng.pick(projectPeople);
+    const members = rng
+      .shuffle(projectPeople)
+      .slice(0, Math.min(8, projectPeople.length));
+
+    // Assign drugs to drug/platform projects
+    const drugLinks =
+      proj.type === "drug"
+        ? [drugs.find((d) => d.id === proj.id) || rng.pick(drugs)]
+        : [rng.pick(drugs)];
+    const platformLinks =
+      proj.type === "platform"
+        ? [platforms.find((p) => p.id === proj.id) || rng.pick(platforms)]
+        : rng.shuffle(platforms).slice(0, 2);
+    const deptLinks = [...new Set(projectTeams.map((t) => t.department))]
+      .map((dId) => departments.find((d) => d.id === dId))
+      .filter(Boolean);
+
+    return {
+      ...proj,
+      iri: `${base}/id/project/${proj.id}`,
+      leader,
+      members,
+      drugLinks,
+      platformLinks,
+      departmentLinks: deptLinks,
+    };
+  });
+
+  // --- Course linking ---
+  const COURSE_CATALOG = [
+    {
+      id: "PHARM-101",
+      title: "Introduction to Drug Discovery",
+      category: "Drug Discovery",
+    },
+    {
+      id: "PHARM-201",
+      title: "Clinical Data Management",
+      category: "Clinical",
+    },
+    {
+      id: "PHARM-301",
+      title: "Advanced Pharmacology",
+      category: "Drug Discovery",
+    },
+    {
+      id: "GMP-101",
+      title: "GMP Compliance Essentials",
+      category: "Manufacturing",
+    },
+    {
+      id: "GMP-201",
+      title: "GMP Advanced Practices",
+      category: "Manufacturing",
+    },
+    {
+      id: "STAT-101",
+      title: "Pharmaceutical Statistics",
+      category: "Analytics",
+    },
+    {
+      id: "STAT-201",
+      title: "Biostatistics for Trials",
+      category: "Analytics",
+    },
+    {
+      id: "BIO-101",
+      title: "Molecular Biology Fundamentals",
+      category: "Genomics",
+    },
+    { id: "BIO-201", title: "Genomics and Sequencing", category: "Genomics" },
+    { id: "REG-101", title: "Regulatory Submissions", category: "Regulatory" },
+    {
+      id: "DATA-101",
+      title: "Data Engineering for Pharma",
+      category: "Data Infrastructure",
+    },
+    { id: "DATA-201", title: "Machine Learning Pipelines", category: "AI/ML" },
+    { id: "AI-101", title: "AI in Drug Development", category: "AI/ML" },
+    { id: "QA-101", title: "Quality Assurance Methods", category: "Quality" },
+    {
+      id: "SEC-101",
+      title: "Cloud Infrastructure Security",
+      category: "Security",
+    },
+  ];
+
+  const coursesToGenerate = Math.min(courseCount, COURSE_CATALOG.length);
+  const linkedCourses = COURSE_CATALOG.slice(0, coursesToGenerate).map(
+    (course, i) => {
+      // Build prerequisite chains: 201 courses require 101 in same category
+      const prereqs = [];
+      if (course.id.includes("201")) {
+        const base101 = COURSE_CATALOG.find(
+          (c) => c.id.includes("101") && c.category === course.category,
+        );
+        if (base101) prereqs.push(base101.id);
+      }
+      if (course.id.includes("301")) {
+        const base201 = COURSE_CATALOG.find(
+          (c) => c.id.includes("201") && c.category === course.category,
+        );
+        if (base201) prereqs.push(base201.id);
+      }
+
+      // Assign platform and drug links by category
+      const relatedPlatforms = platforms.filter(
+        (p) => p.category === course.category,
+      );
+      const platformLink =
+        relatedPlatforms.length > 0
+          ? rng.pick(relatedPlatforms)
+          : rng.pick(platforms);
+      const drugLink = rng.pick(drugs);
+
+      // Assign attendees
+      const attendees = rng.shuffle(people).slice(0, rng.randomInt(3, 8));
+
+      return {
+        ...course,
+        index: i + 1,
+        iri: `${base}/id/course/${course.id}`,
+        prerequisites: prereqs,
+        prerequisiteIris: prereqs.map((pid) => `${base}/id/course/${pid}`),
+        platformLink,
+        drugLink,
+        attendees,
+        date: `2025-${String((i % 12) + 1).padStart(2, "0")}-01`,
+        orgName: "BioNova",
+        orgIri: `${base}/org/headquarters`,
+      };
+    },
+  );
+
+  // --- Event linking ---
+  const EVENT_CATALOG = [
+    "Engineering All-Hands",
+    "Tech Talk: AI in Pharma",
+    "Hackathon 2025",
+    "Architecture Review Board",
+    "Sprint Demo Day",
+    "Drug Discovery Symposium",
+    "Compliance Training Day",
+    "Platform Migration Workshop",
+    "Data Science Summit",
+    "Security Awareness Week",
+  ];
+  const eventsToGenerate = Math.min(eventCount, EVENT_CATALOG.length);
+  const linkedEvents = Array.from({ length: eventsToGenerate }, (_, i) => {
+    const organizer = rng.pick(people.filter((p) => p.is_manager));
+    const attendees = rng.shuffle(people).slice(0, rng.randomInt(5, 15));
+    const aboutProjects = rng
+      .shuffle(linkedProjects)
+      .slice(0, rng.randomInt(1, 3));
+    const aboutDrugs = rng.shuffle(drugs).slice(0, rng.randomInt(0, 2));
+    const aboutPlatforms = rng.shuffle(platforms).slice(0, rng.randomInt(1, 2));
+
+    return {
+      index: i + 1,
+      title: EVENT_CATALOG[i % EVENT_CATALOG.length],
+      iri: `${base}/id/event/event-${i + 1}`,
+      organizer,
+      attendees,
+      aboutProjects,
+      aboutDrugs,
+      aboutPlatforms,
+      date: `2025-${String((i % 12) + 1).padStart(2, "0")}-15`,
+      location: "Cambridge, MA",
+      eventStatus: "EventScheduled",
+    };
+  });
+
+  // --- Blog post linking ---
+  const BLOG_TOPICS = [
+    "AI-Driven Drug Discovery at BioNova",
+    "Our Journey to Cloud-Native Infrastructure",
+    "Building a Culture of Engineering Excellence",
+    "How We Scaled Our Clinical Data Pipeline",
+    "Machine Learning in Pharmaceutical Manufacturing",
+    "Security Best Practices for Life Sciences",
+    "Developer Experience: What We Learned",
+    "The Future of Genomics Technology",
+    "Cross-Functional Collaboration in Drug Development",
+    "Real-World Evidence and Data Analytics",
+    "Platform Engineering at Scale",
+    "Regulatory Technology Innovation",
+    "Quality Engineering in a GMP Environment",
+    "Data Mesh Architecture for Pharma",
+    "Open Source in Pharmaceutical R&D",
+  ];
+
+  const linkedBlogPosts = Array.from({ length: blogCount }, (_, i) => {
+    const author = rng.pick(people);
+    const aboutDrugs = rng.shuffle(drugs).slice(0, rng.randomInt(1, 3));
+    const aboutPlatforms = rng.shuffle(platforms).slice(0, rng.randomInt(1, 3));
+    const aboutProjects = rng
+      .shuffle(linkedProjects)
+      .slice(0, rng.randomInt(0, 2));
+    const mentionsPeople = rng
+      .shuffle(people.filter((p) => p.id !== author.id))
+      .slice(0, rng.randomInt(1, 4));
+
+    const keywords = [
+      ...aboutDrugs.map((d) => d.name),
+      ...aboutPlatforms.map((p) => p.name),
+    ];
+
+    return {
+      index: i + 1,
+      headline: BLOG_TOPICS[i % BLOG_TOPICS.length],
+      iri: `${base}/id/blog/blog-${i + 1}`,
+      identifier: `BLOG-2025-${String(i + 1).padStart(3, "0")}`,
+      author,
+      aboutDrugs,
+      aboutPlatforms,
+      aboutProjects,
+      mentionsPeople,
+      keywords: keywords.join(", "),
+      date: `2025-${String(Math.floor(i / 2) + 1).padStart(2, "0")}-${String(10 + (i % 20)).padStart(2, "0")}`,
+    };
+  });
+
+  // --- Article linking ---
+  const TOPIC_ENTITY_MAP = {
+    clinical: {
+      drugFilter: (d) =>
+        ["oncora", "cardioguard", "immunex-pro"].includes(d.id),
+      platformCategory: "Clinical",
+    },
+    data_ai: { drugFilter: () => true, platformCategory: "AI/ML" },
+    drug_discovery: {
+      drugFilter: () => true,
+      platformCategory: "Drug Discovery",
+    },
+    manufacturing: {
+      drugFilter: (d) => ["genova-rna", "dermashield"].includes(d.id),
+      platformCategory: "Manufacturing",
+    },
+  };
+
+  const linkedArticles = articleTopics.map((topic, i) => {
+    const topicTitle = topic
+      .replace(/_/g, " ")
+      .replace(/\b\w/g, (c) => c.toUpperCase());
+    const mapping = TOPIC_ENTITY_MAP[topic] || {
+      drugFilter: () => true,
+      platformCategory: null,
+    };
+
+    const drugLinks = drugs.filter(mapping.drugFilter).slice(0, 3);
+    const platformLinks = mapping.platformCategory
+      ? platforms
+          .filter((p) => p.category === mapping.platformCategory)
+          .slice(0, 3)
+      : rng.shuffle(platforms).slice(0, 3);
+    const projectLinks = rng.shuffle(linkedProjects).slice(0, 2);
+    const authorLinks = rng.shuffle(people).slice(0, 2);
+
+    return {
+      topic,
+      title: topicTitle,
+      iri: `${base}/id/article/${topic}`,
+      identifier: `ART-${topic.toUpperCase().replace(/_/g, "-")}-001`,
+      author: authorLinks[0],
+      authorLinks,
+      drugLinks,
+      platformLinks,
+      projectLinks,
+      keywords: [
+        ...drugLinks.map((d) => d.name),
+        ...platformLinks.map((p) => p.name),
+      ].join(", "),
+      date: `2025-${String((i % 12) + 1).padStart(2, "0")}-01`,
+    };
+  });
+
+  return {
+    drugs,
+    platforms,
+    projects: linkedProjects,
+    courses: linkedCourses,
+    events: linkedEvents,
+    blogPosts: linkedBlogPosts,
+    articles: linkedArticles,
+  };
+}

package/render/markdown.js

@@ -0,0 +1,126 @@
+/**
+ * Markdown Renderer — generates personal knowledge-base content
+ * for Basecamp personas.
+ *
+ * Uses TemplateLoader from libtemplate for all output.
+ */
+
+const SKILL_NAMES = [
+  "version_control",
+  "code_review",
+  "testing",
+  "deployment",
+  "monitoring",
+  "documentation",
+  "architecture",
+  "security",
+];
+const PROFICIENCIES = [
+  "awareness",
+  "foundational",
+  "working",
+  "practitioner",
+  "expert",
+];
+const LEVEL_IDX = { L1: 0, L2: 1, L3: 2, L4: 3, L5: 4 };
+
+/**
+ * Render Markdown files for Basecamp personas.
+ * @param {object} entities
+ * @param {Map<string,string>} prose
+ * @param {import('@forwardimpact/libtemplate/loader').TemplateLoader} templates - Template loader
+ * @returns {Map<string,string>} path → Markdown content
+ */
+export function renderMarkdown(entities, prose, templates) {
+  if (!templates) throw new Error("templates is required");
+  const files = new Map();
+  const basecampContent = entities.content.find(
+    (c) => c.id === "basecamp_markdown",
+  );
+  if (!basecampContent) return files;
+
+  const personaCount = basecampContent.personas || 0;
+  const personaLevels = basecampContent.persona_levels || ["L2", "L3", "L4"];
+  const candidates = entities.people.filter((p) =>
+    personaLevels.includes(p.level),
+  );
+  const personas = candidates.slice(0, personaCount);
+  const date = new Date().toISOString().split("T")[0];
+
+  for (const person of personas) {
+    const team = entities.teams.find((t) => t.id === person.team_id);
+    const dept = entities.departments.find((d) => d.id === person.department);
+    const prefix = `personas/${person.id}`;
+    const baseIdx = LEVEL_IDX[person.level] || 0;
+
+    const ctx = {
+      personId: person.id,
+      personName: person.name,
+      discipline: person.discipline,
+      level: person.level,
+      email: person.email,
+      teamName: team?.name || "Unknown",
+      deptName: dept?.name || "Unknown",
+      teamSize: team?.size || "?",
+      isManager: person.is_manager ? "Yes" : "No",
+      date,
+    };
+
+    files.set(
+      `${prefix}/daily-briefing.md`,
+      templates.render("briefing.md", {
+        ...ctx,
+        briefing:
+          prose.get(`briefing_${person.id}`) ||
+          `Morning briefing for ${person.name}, ${person.discipline} ${person.level} on ${team?.name || "their team"}.`,
+      }),
+    );
+
+    files.set(
+      `${prefix}/weekly-notes.md`,
+      templates.render("weekly.md", {
+        ...ctx,
+        weeklyNote:
+          prose.get(`weekly_${person.id}`) ||
+          `Weekly reflection for ${person.name}.`,
+      }),
+    );
+
+    files.set(
+      `${prefix}/skill-reflections.md`,
+      templates.render("skill-reflection.md", {
+        ...ctx,
+        skills: SKILL_NAMES.map((s) => ({
+          label: s.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+          proficiency: PROFICIENCIES[Math.min(4, baseIdx)],
+        })),
+        growthNote:
+          baseIdx < 4
+            ? `Target: Move from ${PROFICIENCIES[baseIdx]} to ${PROFICIENCIES[baseIdx + 1]} in key areas.`
+            : "Currently at expert level. Focus on mentoring and knowledge sharing.",
+      }),
+    );
+
+    const personProjects = entities.projects.filter((proj) =>
+      (proj.teams || []).includes(person.team_id),
+    );
+    for (const proj of personProjects) {
+      files.set(
+        `${prefix}/project-${proj.id}.md`,
+        templates.render("project-note.md", {
+          ...ctx,
+          projectId: proj.id,
+          projectName: proj.name,
+          projectType: proj.type,
+          timeline_start: proj.timeline_start,
+          timeline_end: proj.timeline_end,
+          note:
+            prose.get(`project_note_${person.id}_${proj.id}`) ||
+            `Notes on ${proj.name} from ${person.name}'s perspective.`,
+        }),
+      );
+    }
+  }
+
+  return files;
+}

package/render/pathway.js

@@ -0,0 +1,124 @@
+/**
+ * Pathway Renderer — converts LLM-generated JSON to YAML files.
+ *
+ * @module libuniverse/render/pathway
+ */
+
+import YAML from "yaml";
+
+/**
+ * Render pathway YAML files from generated entity data.
+ *
+ * @param {object} pathwayData - Keyed by entity type
+ * @returns {Map<string,string>} path → YAML content
+ */
+export function renderPathway(pathwayData) {
+  const files = new Map();
+
+  // Single-file entities
+  if (pathwayData.framework) {
+    files.set("framework.yaml", toYaml(pathwayData.framework, "framework"));
+  }
+  if (pathwayData.levels) {
+    files.set("levels.yaml", toYaml(pathwayData.levels, "levels"));
+  }
+  if (pathwayData.stages) {
+    files.set("stages.yaml", toYaml(pathwayData.stages, "stages"));
+  }
+  if (pathwayData.drivers) {
+    files.set("drivers.yaml", toYaml(pathwayData.drivers, "drivers"));
+  }
+  if (pathwayData.selfAssessments) {
+    files.set(
+      "self-assessments.yaml",
+      toYaml(pathwayData.selfAssessments, "self-assessments"),
+    );
+  }
+
+  // Multi-file entities (one YAML per entity)
+  if (pathwayData.capabilities) {
+    const capIds = [];
+    for (const cap of pathwayData.capabilities) {
+      const id = cap._id || cap.id;
+      const data = stripInternal(cap);
+      files.set(`capabilities/${id}.yaml`, toYaml(data, "capability"));
+      capIds.push(id);
+    }
+    files.set("capabilities/_index.yaml", renderIndex(capIds));
+  }
+
+  if (pathwayData.behaviours) {
+    const behIds = [];
+    for (const beh of pathwayData.behaviours) {
+      const id = beh._id || beh.id;
+      const data = stripInternal(beh);
+      files.set(`behaviours/${id}.yaml`, toYaml(data, "behaviour"));
+      behIds.push(id);
+    }
+    files.set("behaviours/_index.yaml", renderIndex(behIds));
+  }
+
+  if (pathwayData.disciplines) {
+    const discIds = [];
+    for (const disc of pathwayData.disciplines) {
+      const id = disc._id || disc.id;
+      const data = stripInternal(disc);
+      files.set(`disciplines/${id}.yaml`, toYaml(data, "discipline"));
+      discIds.push(id);
+    }
+    files.set("disciplines/_index.yaml", renderIndex(discIds));
+  }
+
+  if (pathwayData.tracks) {
+    const trackIds = [];
+    for (const track of pathwayData.tracks) {
+      const id = track._id || track.id;
+      const data = stripInternal(track);
+      files.set(`tracks/${id}.yaml`, toYaml(data, "track"));
+      trackIds.push(id);
+    }
+    files.set("tracks/_index.yaml", renderIndex(trackIds));
+  }
+
+  return files;
+}
+
+/**
+ * Convert data to YAML with a schema comment header.
+ *
+ * @param {object} data
+ * @param {string} schemaName
+ * @returns {string}
+ */
+function toYaml(data, schemaName) {
+  const schemaComment = `# yaml-language-server: $schema=https://www.forwardimpact.team/schema/json/${schemaName}.schema.json\n\n`;
+  return schemaComment + YAML.stringify(data, { lineWidth: 80 });
+}
+
+/**
+ * Render an _index.yaml file.
+ *
+ * @param {string[]} ids
+ * @returns {string}
+ */
+function renderIndex(ids) {
+  const content = [
+    "# Auto-generated index for browser loading",
+    "# Do not edit manually - regenerate with: npx pathway --generate-index",
+  ];
+  return content.join("\n") + "\n" + YAML.stringify({ files: ids });
+}
+
+/**
+ * Strip internal properties (prefixed with _) from an object.
+ *
+ * @param {object} obj
+ * @returns {object}
+ */
+function stripInternal(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (!key.startsWith("_")) result[key] = value;
+  }
+  return result;
+}