@thanh01.pmt/curriculum-kit 1.4.0 → 1.4.2

package/dist/standards/index.mjs

@@ -855,9 +855,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
 };
 var BUNDLED_STANDARDS_PACK_IDS = Object.keys(BUNDLED_PACK_RECORDS).sort();
 var parsedPackCache = /* @__PURE__ */ new Map();
@@ -884,7 +1045,37 @@ function resolveStandardsPacks(packIds) {
   }
   return packs;
 }
+function findStandardStatement(statementIdOrRef) {
+  if (!statementIdOrRef) return null;
+  const [packPrefix, ...rest] = statementIdOrRef.split(":");
+  const targetId = rest.length > 0 ? rest.join(":") : statementIdOrRef;
+  const packs = resolveStandardsPacks(BUNDLED_STANDARDS_PACK_IDS);
+  for (const pack of packs) {
+    if (rest.length > 0 && pack.manifest.id !== packPrefix) continue;
+    const stmt = pack.statements.find((s) => s.id.toLowerCase() === targetId.toLowerCase());
+    if (stmt) {
+      const description = stmt.texts["en"] || Object.values(stmt.texts)[0] || "";
+      const category = stmt.classifications && stmt.classifications.length > 0 ? stmt.classifications.map((c) => c.value).join(", ") : void 0;
+      const gradeBand = Array.isArray(stmt.gradeBand) ? stmt.gradeBand[0] === stmt.gradeBand[1] ? String(stmt.gradeBand[0]) : `${stmt.gradeBand[0]}-${stmt.gradeBand[1]}` : void 0;
+      return {
+        packId: pack.manifest.id,
+        packTitle: pack.manifest.name,
+        statementId: stmt.id,
+        description,
+        category,
+        gradeBand
+      };
+    }
+  }
+  return null;
+}
+var STANDARD_REF_REGEX = /\b(?:(?:csta-k12-2017|acm-ieee-cs2023):)?(?:[1-3][A-B]?-[A-Z]{2}-\d{2}|CS2023-[A-Z0-9_-]+)\b/gi;
+function extractStandardRefs(text) {
+  if (!text) return [];
+  const matches = Array.from(text.matchAll(STANDARD_REF_REGEX)).map((m) => m[0]);
+  return Array.from(new Set(matches));
+}
 
-export { BUNDLED_STANDARDS_PACK_IDS, BloomHintSchema, ClassificationSchema, FrameworkMappingSchema, FrameworkPackManifestSchema, FrameworkPackSchema, FrameworkStatementSchema, GradeBandSchema, MappingKindSchema, RecordProvenanceSchema, StandardsRegistryAdapter, buildStandardStackMarkdown, buildStandardsContext, buildStandardsContextBlock, evaluateStandardsCoverage, lintFrameworkPack, resolveStandardsPacks, selectStatementsForLesson, validateFrameworkPack };
+export { BUNDLED_STANDARDS_PACK_IDS, BloomHintSchema, ClassificationSchema, FrameworkMappingSchema, FrameworkPackManifestSchema, FrameworkPackSchema, FrameworkStatementSchema, GradeBandSchema, MappingKindSchema, RecordProvenanceSchema, STANDARD_REF_REGEX, StandardsRegistryAdapter, buildStandardStackMarkdown, buildStandardsContext, buildStandardsContextBlock, evaluateStandardsCoverage, extractStandardRefs, findStandardStatement, lintFrameworkPack, resolveStandardsPacks, selectStatementsForLesson, validateFrameworkPack };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map