@thanh01.pmt/curriculum-kit 1.4.1 → 1.4.2

package/dist/workflow/index.cjs

@@ -1111,7 +1111,9 @@ var LessonPlanSchema = zod.z.object({
     name: zod.z.string().optional().default(""),
     description: zod.z.string(),
     bloomLevel: zod.z.string().default("understand"),
-    successCriteria: zod.z.string().optional().default("")
+    successCriteria: zod.z.string().optional().default(""),
+    standardRefs: zod.z.array(zod.z.string()).optional(),
+    conceptRefs: zod.z.array(zod.z.string()).optional()
   })).default([]),
   prerequisites: zod.z.string().optional().default(""),
   materialsSummary: zod.z.string().optional().default(""),
@@ -5634,9 +5636,170 @@ var csta_k12_2017_default = {
   ]
 };
 
+// src/standards/data/acm-ieee-cs2023.json
+var acm_ieee_cs2023_default = {
+  manifest: {
+    id: "acm-ieee-cs2023",
+    name: "ACM/IEEE-CS/AAAI Computer Science Curricula 2023 (CS2023)",
+    specVersion: "1.0",
+    contentVersion: "2023.1",
+    subject: "computing",
+    languages: ["en"],
+    gradeModel: {
+      type: "grades",
+      range: [9, 16]
+    },
+    provenance: {
+      sourceRef: "ACM/IEEE-CS/AAAI Computer Science Curricula 2023 - cs2023.org",
+      sourceUrl: "https://cs2023.org",
+      license: "ACM / IEEE Computer Society (cited verbatim for curriculum alignment)",
+      importedBy: "platform",
+      importedAt: "2026-09-11T00:00:00.000Z"
+    },
+    trust: "verified"
+  },
+  statements: [
+    {
+      id: "CS2023-SDF-01",
+      gradeBand: [9, 14],
+      texts: {
+        en: "Design, implement, test, and debug programs using basic computation, standard conditional and iterative structures, and functions."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Software Development Fundamentals (SDF)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Apply" },
+      keywords: ["algorithms", "control structures", "functions", "variables", "debugging", "programming", "implementation"],
+      sourceRef: "CS2023, Software Development Fundamentals, Program Construction",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-SDF-02",
+      gradeBand: [9, 14],
+      texts: {
+        en: "Apply fundamental data structures (arrays, lists, stacks, queues, hash maps) to represent collections of data and solve algorithmic problems."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Software Development Fundamentals (SDF)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Apply" },
+      keywords: ["data structures", "arrays", "lists", "hash maps", "collections", "stacks", "queues"],
+      sourceRef: "CS2023, Software Development Fundamentals, Fundamental Data Structures",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-AL-01",
+      gradeBand: [10, 16],
+      texts: {
+        en: "Analyze and compare the time and space complexity of fundamental algorithms using asymptotic notation (Big-O)."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Algorithms and Complexity (AL)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Analyze" },
+      keywords: ["complexity", "big-o", "efficiency", "sorting", "searching", "asymptotic", "runtime"],
+      sourceRef: "CS2023, Algorithms and Complexity, Basic Analysis",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-SE-01",
+      gradeBand: [9, 16],
+      texts: {
+        en: "Decompose complex problems into modular software components applying principles of abstraction, encapsulation, and separation of concerns."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Software Engineering (SE)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Create" },
+      keywords: ["modularity", "abstraction", "software design", "refactoring", "encapsulation", "architecture"],
+      sourceRef: "CS2023, Software Engineering, Software Design and Architecture",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-SEC-01",
+      gradeBand: [9, 16],
+      texts: {
+        en: "Incorporate defensive programming and fundamental cybersecurity principles (least privilege, input validation, secure data handling) into software development."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Security (SEC)" },
+        { axis: "Core Tier", value: "Tier-1 Core" }
+      ],
+      bloomHint: { process: "Apply" },
+      keywords: ["security", "defensive programming", "input validation", "cybersecurity", "vulnerabilities"],
+      sourceRef: "CS2023, Security, Secure Software Development",
+      provenance: { method: "source_official" }
+    },
+    {
+      id: "CS2023-AI-01",
+      gradeBand: [10, 16],
+      texts: {
+        en: "Formulate machine learning tasks, prepare training and evaluation datasets, and evaluate model performance using standard metrics."
+      },
+      classifications: [
+        { axis: "Knowledge Area", value: "Artificial Intelligence (AI)" },
+        { axis: "Core Tier", value: "Tier-2 Core" }
+      ],
+      bloomHint: { process: "Evaluate" },
+      keywords: ["artificial intelligence", "machine learning", "dataset", "evaluation", "model", "accuracy"],
+      sourceRef: "CS2023, Artificial Intelligence, Machine Learning Fundamentals",
+      provenance: { method: "source_official" }
+    }
+  ],
+  mappings: [
+    {
+      statementId: "CS2023-SDF-01",
+      targetRef: "ontora:PROGRAM_CONSTRUCTION",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-SDF-02",
+      targetRef: "ontora:DATA_STRUCTURES",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-AL-01",
+      targetRef: "ontora:ALGORITHM_COMPLEXITY",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-SE-01",
+      targetRef: "ontora:SOFTWARE_ARCHITECTURE",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-SEC-01",
+      targetRef: "ontora:DEFENSIVE_PROGRAMMING",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    },
+    {
+      statementId: "CS2023-AI-01",
+      targetRef: "ontora:MACHINE_LEARNING",
+      kind: "covers",
+      confidence: 0.95,
+      provenance: { method: "source_official" }
+    }
+  ]
+};
+
 // src/standards/bundledPacks.ts
 var BUNDLED_PACK_RECORDS = {
-  "csta-k12-2017": csta_k12_2017_default
+  "csta-k12-2017": csta_k12_2017_default,
+  "acm-ieee-cs2023": acm_ieee_cs2023_default
 };
 Object.keys(BUNDLED_PACK_RECORDS).sort();
 
@@ -6243,7 +6406,6 @@ var DEFAULT_KX_PRIORITIES = [
 ];
 function buildSectionAwareExcerpt(markdown, opts = {}) {
   const budget = opts.budget ?? 12e3;
-  const minContentChars = opts.minContentChars ?? 400;
   const issues = [];
   const source = (markdown || "").trim();
   if (!source) {
@@ -6256,6 +6418,7 @@ function buildSectionAwareExcerpt(markdown, opts = {}) {
       tokenEstimate: 0
     };
   }
+  const minContentChars = opts.minContentChars !== void 0 ? opts.minContentChars : Math.min(400, source.length);
   const slcMap = normalizeSlcContract(opts.sectionLanguageContract);
   const effectiveArtifactType = opts.artifactType || deriveArtifactTypeFromFileName(opts.fileName);
   const sections = parseMarkdownSections(source, slcMap, effectiveArtifactType);
@@ -6275,44 +6438,74 @@ function buildSectionAwareExcerpt(markdown, opts = {}) {
     };
   }
   const byCanonical = /* @__PURE__ */ new Map();
+  const byCleanTitle = /* @__PURE__ */ new Map();
   const unmatched = [];
   for (const s of sections) {
     if (s.canonicalKey && !byCanonical.has(s.canonicalKey)) {
       byCanonical.set(s.canonicalKey, s);
-    } else {
+    }
+    const norm = normalizeHeading(s.cleanTitle);
+    if (!byCleanTitle.has(norm)) {
+      byCleanTitle.set(norm, s);
+    }
+    if (!s.canonicalKey) {
       unmatched.push(s);
     }
   }
   const priorities = opts.priorities ?? DEFAULT_LESSON_PRIORITIES;
   const includedSections = [];
   const blocks = [];
-  let used = 0;
+  const initialOverhead = metaBlock ? metaBlock.length + 2 : 0;
+  let used = initialOverhead;
   const tryAdd = (heading, body, key) => {
     const trimmedBody = body.trim();
     if (!trimmedBody) return false;
     const block = `## ${heading}
 
 ${trimmedBody}`;
-    if (used + block.length > budget && used > 0) return false;
-    blocks.push(block);
-    used += block.length;
-    includedSections.push(key);
-    return true;
+    if (used + block.length <= budget) {
+      blocks.push(block);
+      used += block.length;
+      includedSections.push(key);
+      return true;
+    }
+    if (includedSections.length === 0 && budget >= minContentChars) {
+      const headingOverhead = `## ${heading}
+
+`.length;
+      const remaining = budget - used;
+      if (remaining > headingOverhead + 50) {
+        const allowedBody = remaining - headingOverhead;
+        const truncated = truncateByBudget(trimmedBody, allowedBody).trim();
+        if (truncated.length > 0) {
+          const partialBlock = `## ${heading}
+
+${truncated}`;
+          blocks.push(partialBlock);
+          used += partialBlock.length;
+          includedSections.push(key);
+          issues.push(`section:truncated:${key}`);
+          return true;
+        }
+      }
+    }
+    return false;
   };
   blocks.push(metaBlock);
   let sectionAware = false;
   for (const key of priorities) {
-    const sec = byCanonical.get(key);
+    const sec = byCanonical.get(key) || byCleanTitle.get(normalizeHeading(key));
     if (!sec) continue;
     sectionAware = true;
     if (!tryAdd(sec.cleanTitle, sec.body, key)) break;
   }
   for (const [key, sec] of byCanonical) {
-    if (includedSections.includes(key)) continue;
+    if (includedSections.includes(key) || includedSections.includes(sec.cleanTitle)) continue;
     if (used >= budget) break;
     if (!tryAdd(sec.cleanTitle, sec.body, key)) break;
   }
   for (const sec of unmatched) {
+    if (includedSections.includes(sec.cleanTitle)) continue;
     if (used >= budget) break;
     if (!tryAdd(sec.cleanTitle, sec.body, sec.cleanTitle)) break;
   }
@@ -6320,17 +6513,16 @@ ${trimmedBody}`;
     issues.push("parse:no-canonical-resolution");
   }
   if (priorities.length > 0 && !priorities.some((k) => includedSections.includes(k))) {
-    issues.push("parse:no-priority-resolution");
+    issues.push(sections.length === 0 ? "parse:no-sections" : "parse:no-priority-resolution");
   }
   let excerpt = blocks.join("\n\n");
   if (excerpt.length > budget) {
     excerpt = truncateByBudget(excerpt, budget);
   }
-  const effectiveMinChars = Math.min(minContentChars, source.length);
-  if (excerpt.length - metaBlock.length < effectiveMinChars) {
+  if (excerpt.length - metaBlock.length < minContentChars) {
     issues.push("content:insufficient");
   }
-  const verified = !issues.includes("parse:no-priority-resolution") && !issues.includes("parse:no-canonical-resolution") && excerpt.length - metaBlock.length >= effectiveMinChars;
+  const verified = !issues.includes("parse:no-priority-resolution") && !issues.includes("parse:no-canonical-resolution") && excerpt.length - metaBlock.length >= minContentChars;
   return {
     excerpt,
     verified,
@@ -6390,7 +6582,7 @@ function parseMarkdownSections(markdown, slcMap, artifactType) {
     }
   }
   const flush = () => {
-    if (!currentHeading && currentBody.length === 0) return;
+    if (!currentHeading) return;
     const cleanTitle = currentHeading.replace(/^#{1,4}\s+/, "").trim();
     const norm = normalizeHeading(cleanTitle);
     const canonicalKey = reverseMap.get(norm) || findCanonicalFuzzy(norm);