@documentation-robotics/cli 0.1.0 → 0.1.7

package/dist/audit/nodes/analysis/node-definition-analyzer.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/analysis/node-definition-analyzer.ts"],
+  "sourcesContent": ["/**\n * Node definition quality analyzer.\n * Pure function \u2014 no I/O.\n */\n\nimport type { ParsedNodeSchema, NodeDefinitionQuality, DefinitionIssue } from \"../types.js\";\n\nconst GENERIC_DESCRIPTION_RE = /\\w+ element in \\w+ layer/i;\n\n/**\n * Classify description quality for a node schema.\n */\nfunction classifyDescription(description: string): \"empty\" | \"generic\" | \"good\" {\n  if (!description || description.trim() === \"\") return \"empty\";\n  if (GENERIC_DESCRIPTION_RE.test(description)) return \"generic\";\n  return \"good\";\n}\n\n/**\n * Count how many attribute properties have a non-empty description field.\n */\nfunction countDocumentedAttributes(\n  properties: Record<string, { type?: string; description?: string; format?: string; enum?: string[] }>\n): number {\n  return Object.values(properties).filter(\n    (p) => typeof p.description === \"string\" && p.description.trim() !== \"\"\n  ).length;\n}\n\nexport class NodeDefinitionAnalyzer {\n  analyze(schema: ParsedNodeSchema): NodeDefinitionQuality {\n    const issues: DefinitionIssue[] = [];\n    let score = 100;\n\n    const descriptionQuality = classifyDescription(schema.description);\n    const hasDescription = descriptionQuality !== \"empty\";\n\n    // Description issues\n    if (descriptionQuality === \"empty\") {\n      issues.push({\n        severity: \"error\",\n        code: \"EMPTY_DESCRIPTION\",\n        message: `Node type \"${schema.specNodeId}\" has no description.`,\n      });\n      score -= 30;\n    } else if (descriptionQuality === \"generic\") {\n      issues.push({\n        severity: \"warning\",\n        code: \"GENERIC_DESCRIPTION\",\n        message: `Node type \"${schema.specNodeId}\" uses generic template description: \"${schema.description}\"`,\n      });\n      score -= 15;\n    } else if (schema.description.trim().length < 20) {\n      issues.push({\n        severity: \"info\",\n        code: \"SHORT_DESCRIPTION\",\n        message: `Node type \"${schema.specNodeId}\" has a very short description (${schema.description.trim().length} chars).`,\n      });\n      score -= 5;\n    }\n\n    // Attribute documentation\n    const attributeCount = Object.keys(schema.attributes.properties).length;\n    const documentedAttributeCount = countDocumentedAttributes(schema.attributes.properties);\n    const attributeDocumentationRatio =\n      attributeCount > 0 ? documentedAttributeCount / attributeCount : 1.0;\n\n    if (attributeCount > 3 && attributeDocumentationRatio < 0.5) {\n      issues.push({\n        severity: \"warning\",\n        code: \"LOW_ATTRIBUTE_DOCUMENTATION\",\n        message: `Node type \"${schema.specNodeId}\" has low attribute documentation: ${documentedAttributeCount}/${attributeCount} attributes described.`,\n      });\n      score -= 10;\n    }\n\n    return {\n      specNodeId: schema.specNodeId,\n      layerId: schema.layerId,\n      hasDescription,\n      descriptionQuality,\n      attributeCount,\n      documentedAttributeCount,\n      attributeDocumentationRatio,\n      issues,\n      score: Math.max(0, score),\n    };\n  }\n}\n"],
+  "mappings": "AAOA,MAAM,yBAAyB;AAK/B,SAAS,oBAAoB,aAAmB;AAC9C,SAAI,CAAC,eAAe,YAAY,KAAI,MAAO,KAAW,UAClD,uBAAuB,KAAK,WAAW,IAAU,YAC9C;AACT;AAKA,SAAS,0BACP,YAAqG;AAErG,SAAO,OAAO,OAAO,UAAU,EAAE,OAC/B,CAAC,MAAM,OAAO,EAAE,eAAgB,YAAY,EAAE,YAAY,KAAI,MAAO,EAAE,EACvE;AACJ;AAEM,MAAO,uBAAsB;EACjC,QAAQ,QAAwB;AAC9B,UAAM,SAA4B,CAAA;AAClC,QAAI,QAAQ;AAEZ,UAAM,qBAAqB,oBAAoB,OAAO,WAAW,GAC3D,iBAAiB,uBAAuB;AAG9C,IAAI,uBAAuB,WACzB,OAAO,KAAK;MACV,UAAU;MACV,MAAM;MACN,SAAS,cAAc,OAAO,UAAU;KACzC,GACD,SAAS,MACA,uBAAuB,aAChC,OAAO,KAAK;MACV,UAAU;MACV,MAAM;MACN,SAAS,cAAc,OAAO,UAAU,yCAAyC,OAAO,WAAW;KACpG,GACD,SAAS,MACA,OAAO,YAAY,KAAI,EAAG,SAAS,OAC5C,OAAO,KAAK;MACV,UAAU;MACV,MAAM;MACN,SAAS,cAAc,OAAO,UAAU,mCAAmC,OAAO,YAAY,KAAI,EAAG,MAAM;KAC5G,GACD,SAAS;AAIX,UAAM,iBAAiB,OAAO,KAAK,OAAO,WAAW,UAAU,EAAE,QAC3D,2BAA2B,0BAA0B,OAAO,WAAW,UAAU,GACjF,8BACJ,iBAAiB,IAAI,2BAA2B,iBAAiB;AAEnE,WAAI,iBAAiB,KAAK,8BAA8B,QACtD,OAAO,KAAK;MACV,UAAU;MACV,MAAM;MACN,SAAS,cAAc,OAAO,UAAU,sCAAsC,wBAAwB,IAAI,cAAc;KACzH,GACD,SAAS,KAGJ;MACL,YAAY,OAAO;MACnB,SAAS,OAAO;MAChB;MACA;MACA;MACA;MACA;MACA;MACA,OAAO,KAAK,IAAI,GAAG,KAAK;;EAE5B;;",
+  "names": []
+}

package/dist/audit/nodes/analysis/node-overlap-detector.js

@@ -0,0 +1,79 @@
+function levenshteinDistance(a, b) {
+  const m = a.length, n = b.length, dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0));
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      a[i - 1] === b[j - 1] ? dp[i][j] = dp[i - 1][j - 1] : dp[i][j] = 1 + Math.min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]);
+  return dp[m][n];
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0)
+    return 1;
+  const intersection = new Set([...a].filter((x) => b.has(x))), union = /* @__PURE__ */ new Set([...a, ...b]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+function tokenize(text) {
+  return new Set(text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 2));
+}
+class NodeOverlapDetector {
+  detectOverlaps(schemas) {
+    const candidates = [], byLayer = /* @__PURE__ */ new Map();
+    for (const schema of schemas) {
+      const group = byLayer.get(schema.layerId) ?? [];
+      group.push(schema), byLayer.set(schema.layerId, group);
+    }
+    for (const [layerId, layerSchemas] of byLayer) {
+      const n = layerSchemas.length;
+      for (let i = 0; i < n; i++)
+        for (let j = i + 1; j < n; j++) {
+          const a = layerSchemas[i], b = layerSchemas[j], candidate = this.comparePair(a, b, layerId);
+          candidate && candidates.push(candidate);
+        }
+    }
+    return candidates;
+  }
+  comparePair(a, b, layerId) {
+    const nameA = a.typeName.toLowerCase(), nameB = b.typeName.toLowerCase(), nameDist = levenshteinDistance(nameA, nameB);
+    if (Math.min(nameA.length, nameB.length) >= 6 && nameDist <= 2)
+      return {
+        nodeTypeA: a.specNodeId,
+        nodeTypeB: b.specNodeId,
+        layerId,
+        reason: `Type names "${nameA}" and "${nameB}" differ by only ${nameDist} character(s).`,
+        confidence: "high",
+        overlapType: "name_similarity"
+      };
+    const keysA = new Set(Object.keys(a.attributes.properties)), keysB = new Set(Object.keys(b.attributes.properties));
+    if (keysA.size > 0 && keysB.size > 0) {
+      const attrJaccard = jaccardSimilarity(keysA, keysB);
+      if (attrJaccard > 0.8 && nameDist <= 4)
+        return {
+          nodeTypeA: a.specNodeId,
+          nodeTypeB: b.specNodeId,
+          layerId,
+          reason: `Attribute sets are ${(attrJaccard * 100).toFixed(0)}% similar (Jaccard) with name distance ${nameDist}.`,
+          confidence: "high",
+          overlapType: "attribute_similarity"
+        };
+    }
+    if (a.description && b.description) {
+      const wordsA = tokenize(a.description), wordsB = tokenize(b.description);
+      if (wordsA.size >= 4 && wordsB.size >= 4) {
+        const descJaccard = jaccardSimilarity(wordsA, wordsB);
+        if (descJaccard > 0.7)
+          return {
+            nodeTypeA: a.specNodeId,
+            nodeTypeB: b.specNodeId,
+            layerId,
+            reason: `Descriptions share ${(descJaccard * 100).toFixed(0)}% word overlap.`,
+            confidence: "medium",
+            overlapType: "description_similarity"
+          };
+      }
+    }
+    return null;
+  }
+}
+export {
+  NodeOverlapDetector
+};
+//# sourceMappingURL=node-overlap-detector.js.map

package/dist/audit/nodes/analysis/node-overlap-detector.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/analysis/node-overlap-detector.ts"],
+  "sourcesContent": ["/**\n * Node semantic overlap detector.\n * Pure function \u2014 no I/O.\n *\n * Compares all pairs within a layer (O(n\u00B2)) to find potentially duplicate\n * node types based on name similarity, attribute overlap, or description overlap.\n */\n\nimport type { ParsedNodeSchema, SemanticOverlapCandidate } from \"../types.js\";\n\n/**\n * Compute Levenshtein edit distance between two strings.\n */\nfunction levenshteinDistance(a: string, b: string): number {\n  const m = a.length;\n  const n = b.length;\n  const dp: number[][] = Array.from({ length: m + 1 }, (_, i) =>\n    Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0))\n  );\n\n  for (let i = 1; i <= m; i++) {\n    for (let j = 1; j <= n; j++) {\n      if (a[i - 1] === b[j - 1]) {\n        dp[i][j] = dp[i - 1][j - 1];\n      } else {\n        dp[i][j] = 1 + Math.min(dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]);\n      }\n    }\n  }\n  return dp[m][n];\n}\n\n/**\n * Jaccard similarity of two sets of strings.\n */\nfunction jaccardSimilarity(a: Set<string>, b: Set<string>): number {\n  if (a.size === 0 && b.size === 0) return 1.0;\n  const intersection = new Set([...a].filter((x) => b.has(x)));\n  const union = new Set([...a, ...b]);\n  return union.size === 0 ? 0 : intersection.size / union.size;\n}\n\n/**\n * Tokenize a description into lowercase words for overlap comparison.\n */\nfunction tokenize(text: string): Set<string> {\n  return new Set(\n    text\n      .toLowerCase()\n      .replace(/[^a-z0-9\\s]/g, \" \")\n      .split(/\\s+/)\n      .filter((w) => w.length > 2)\n  );\n}\n\nexport class NodeOverlapDetector {\n  detectOverlaps(schemas: ParsedNodeSchema[]): SemanticOverlapCandidate[] {\n    const candidates: SemanticOverlapCandidate[] = [];\n\n    // Group by layer\n    const byLayer = new Map<string, ParsedNodeSchema[]>();\n    for (const schema of schemas) {\n      const group = byLayer.get(schema.layerId) ?? [];\n      group.push(schema);\n      byLayer.set(schema.layerId, group);\n    }\n\n    for (const [layerId, layerSchemas] of byLayer) {\n      const n = layerSchemas.length;\n      for (let i = 0; i < n; i++) {\n        for (let j = i + 1; j < n; j++) {\n          const a = layerSchemas[i];\n          const b = layerSchemas[j];\n\n          const candidate = this.comparePair(a, b, layerId);\n          if (candidate) candidates.push(candidate);\n        }\n      }\n    }\n\n    return candidates;\n  }\n\n  private comparePair(\n    a: ParsedNodeSchema,\n    b: ParsedNodeSchema,\n    layerId: string\n  ): SemanticOverlapCandidate | null {\n    // Name similarity: strip layer prefix, compare type names\n    const nameA = a.typeName.toLowerCase();\n    const nameB = b.typeName.toLowerCase();\n    const nameDist = levenshteinDistance(nameA, nameB);\n    const minNameLen = Math.min(nameA.length, nameB.length);\n\n    if (minNameLen >= 6 && nameDist <= 2) {\n      return {\n        nodeTypeA: a.specNodeId,\n        nodeTypeB: b.specNodeId,\n        layerId,\n        reason: `Type names \"${nameA}\" and \"${nameB}\" differ by only ${nameDist} character(s).`,\n        confidence: \"high\",\n        overlapType: \"name_similarity\",\n      };\n    }\n\n    // Attribute similarity: Jaccard > 0.8 AND name distance <= 4\n    const keysA = new Set(Object.keys(a.attributes.properties));\n    const keysB = new Set(Object.keys(b.attributes.properties));\n    if (keysA.size > 0 && keysB.size > 0) {\n      const attrJaccard = jaccardSimilarity(keysA, keysB);\n      if (attrJaccard > 0.8 && nameDist <= 4) {\n        return {\n          nodeTypeA: a.specNodeId,\n          nodeTypeB: b.specNodeId,\n          layerId,\n          reason: `Attribute sets are ${(attrJaccard * 100).toFixed(0)}% similar (Jaccard) with name distance ${nameDist}.`,\n          confidence: \"high\",\n          overlapType: \"attribute_similarity\",\n        };\n      }\n    }\n\n    // Description similarity: Jaccard word overlap > 0.7 (only for \"good\" descriptions)\n    if (a.description && b.description) {\n      const wordsA = tokenize(a.description);\n      const wordsB = tokenize(b.description);\n      if (wordsA.size >= 4 && wordsB.size >= 4) {\n        const descJaccard = jaccardSimilarity(wordsA, wordsB);\n        if (descJaccard > 0.7) {\n          return {\n            nodeTypeA: a.specNodeId,\n            nodeTypeB: b.specNodeId,\n            layerId,\n            reason: `Descriptions share ${(descJaccard * 100).toFixed(0)}% word overlap.`,\n            confidence: \"medium\",\n            overlapType: \"description_similarity\",\n          };\n        }\n      }\n    }\n\n    return null;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["_"]
+}

package/dist/audit/nodes/model/orchestrator.js

@@ -0,0 +1,82 @@
+import { Model } from "../../../core/model.js";
+import { getAllLayers } from "../../../generated/layer-registry.js";
+class ModelNodeAuditOrchestrator {
+  async runAudit(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    let model;
+    try {
+      model = await Model.load(projectRoot);
+    } catch (err) {
+      throw new Error(`Failed to load project model from ${projectRoot}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const allElements = [];
+    for (const layer of model.layers.values())
+      for (const el of layer.elements.values())
+        allElements.push(el);
+    const getElementLayer = (el) => el.layer_id || el.layer || "", getElementType = (el) => el.spec_node_id || el.type || "", filteredElements = options.layer ? allElements.filter((el) => getElementLayer(el) === options.layer) : allElements, elementsByLayerAndType = /* @__PURE__ */ new Map(), completenessIssues = [];
+    for (const el of filteredElements) {
+      const layerId = getElementLayer(el), typeKey = getElementType(el);
+      if (!layerId || !typeKey) {
+        const elId = el.id ?? "(no id)", missingField = layerId ? "type" : "layer";
+        process.stderr.write(`  \u26A0\uFE0F  Skipping malformed element "${elId}": missing ${missingField}
+`), completenessIssues.push({
+          layerId: layerId || "(unknown)",
+          specNodeId: typeKey || "(unknown)",
+          issueType: "malformed_element",
+          detail: `Element "${elId}" is missing its ${missingField} \u2014 excluded from audit report`
+        });
+        continue;
+      }
+      elementsByLayerAndType.has(layerId) || elementsByLayerAndType.set(layerId, /* @__PURE__ */ new Map());
+      const typeMap = elementsByLayerAndType.get(layerId);
+      typeMap.has(typeKey) || typeMap.set(typeKey, []), typeMap.get(typeKey).push(el);
+    }
+    const layerSummaries = (options.layer ? [options.layer] : getAllLayers().map((l) => l.id)).map((layerId) => {
+      const typeMap = elementsByLayerAndType.get(layerId) ?? /* @__PURE__ */ new Map();
+      let emptyDescriptionCount = 0, genericDescriptionCount = 0, goodDescriptionCount = 0, totalScore = 0;
+      for (const [, elements] of typeMap) {
+        const descs = elements.map((e) => (e.description || "").trim()).filter((d) => d.length > 0);
+        let quality;
+        descs.length === 0 ? quality = "empty" : quality = descs.reduce((s, d) => s + d.length, 0) / descs.length < 20 ? "generic" : "good", quality === "empty" ? (emptyDescriptionCount++, totalScore += 0) : quality === "generic" ? (genericDescriptionCount++, totalScore += 30) : (goodDescriptionCount++, totalScore += 85);
+      }
+      const totalNodeTypes2 = typeMap.size, avgQualityScore = totalNodeTypes2 > 0 ? Math.round(totalScore / totalNodeTypes2 * 10) / 10 : 0;
+      return {
+        layerId,
+        totalNodeTypes: totalNodeTypes2,
+        avgQualityScore,
+        emptyDescriptionCount,
+        genericDescriptionCount,
+        goodDescriptionCount,
+        totalIssues: emptyDescriptionCount + genericDescriptionCount,
+        errorCount: 0,
+        warningCount: emptyDescriptionCount + genericDescriptionCount
+      };
+    });
+    for (const [layerId, typeMap] of elementsByLayerAndType)
+      for (const specNodeId of typeMap.keys())
+        specNodeId.startsWith(`${layerId}.`) || completenessIssues.push({
+          layerId,
+          specNodeId,
+          issueType: "orphaned_schema",
+          detail: `Element uses spec_node_id "${specNodeId}" which does not belong to layer "${layerId}"`
+        });
+    const totalNodeTypes = [...elementsByLayerAndType.values()].reduce((sum, m) => sum + m.size, 0);
+    return options.verbose && process.stderr.write(`Model node audit: ${filteredElements.length} elements, ${totalNodeTypes} unique types across ${elementsByLayerAndType.size} layers
+`), {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      spec: {
+        version: model.manifest.version ?? "1.0.0",
+        totalNodeTypes,
+        totalLayers: elementsByLayerAndType.size
+      },
+      layerSummaries,
+      definitionQuality: [],
+      overlaps: [],
+      completenessIssues
+    };
+  }
+}
+export {
+  ModelNodeAuditOrchestrator
+};
+//# sourceMappingURL=orchestrator.js.map

package/dist/audit/nodes/model/orchestrator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/model/orchestrator.ts"],
+  "sourcesContent": ["/**\n * Model Node Audit Orchestrator\n *\n * Analyzes the project's actual model elements to report which node types\n * are in use, their distribution across layers, and types that exist in the\n * model but not in the spec (orphaned) or vice versa.\n *\n * This is the model-side counterpart to NodeAuditOrchestrator (spec audit).\n * Use `dr audit --type nodes` to invoke this from the CLI.\n */\n\nimport { Model } from \"../../../core/model.js\";\nimport { getAllLayers } from \"../../../generated/layer-registry.js\";\nimport type { Element } from \"../../../core/element.js\";\nimport type {\n  NodeAuditReport,\n  NodeLayerSummary,\n  SchemaCompletenessIssue,\n} from \"../types.js\";\n\nexport interface ModelNodeAuditOptions {\n  layer?: string;\n  verbose?: boolean;\n  projectRoot?: string;\n}\n\nexport class ModelNodeAuditOrchestrator {\n  async runAudit(options: ModelNodeAuditOptions = {}): Promise<NodeAuditReport> {\n    const projectRoot = options.projectRoot ?? process.cwd();\n\n    let model: Model;\n    try {\n      model = await Model.load(projectRoot);\n    } catch (err) {\n      throw new Error(\n        `Failed to load project model from ${projectRoot}: ${err instanceof Error ? err.message : String(err)}`\n      );\n    }\n\n    // Collect all elements across all layers\n    const allElements: Element[] = [];\n    for (const layer of model.layers.values()) {\n      for (const el of layer.elements.values()) {\n        allElements.push(el);\n      }\n    }\n\n    const getElementLayer = (el: Element): string => el.layer_id || el.layer || \"\";\n    const getElementType = (el: Element): string => el.spec_node_id || el.type || \"\";\n\n    // Filter by layer if specified\n    const filteredElements = options.layer\n      ? allElements.filter((el) => getElementLayer(el) === options.layer)\n      : allElements;\n\n    // Group elements by layer \u2192 type \u2192 element list (for quality scoring)\n    const elementsByLayerAndType = new Map<string, Map<string, Element[]>>();\n    const completenessIssues: SchemaCompletenessIssue[] = [];\n\n    for (const el of filteredElements) {\n      const layerId = getElementLayer(el);\n      const typeKey = getElementType(el);\n      if (!layerId || !typeKey) {\n        const elId = (el as unknown as { id?: string }).id ?? \"(no id)\";\n        const missingField = !layerId ? \"layer\" : \"type\";\n        process.stderr.write(\n          `  \u26A0\uFE0F  Skipping malformed element \"${elId}\": missing ${missingField}\\n`\n        );\n        completenessIssues.push({\n          layerId: layerId || \"(unknown)\",\n          specNodeId: typeKey || \"(unknown)\",\n          issueType: \"malformed_element\",\n          detail: `Element \"${elId}\" is missing its ${missingField} \u2014 excluded from audit report`,\n        });\n        continue;\n      }\n      if (!elementsByLayerAndType.has(layerId)) elementsByLayerAndType.set(layerId, new Map());\n      const typeMap = elementsByLayerAndType.get(layerId)!;\n      if (!typeMap.has(typeKey)) typeMap.set(typeKey, []);\n      typeMap.get(typeKey)!.push(el);\n    }\n\n    // Determine target layers\n    const targetLayerIds = options.layer\n      ? [options.layer]\n      : getAllLayers().map((l) => l.id);\n\n    // Build layer summaries with actual description quality scores\n    const layerSummaries: NodeLayerSummary[] = targetLayerIds.map((layerId) => {\n      const typeMap = elementsByLayerAndType.get(layerId) ?? new Map();\n      let emptyDescriptionCount = 0;\n      let genericDescriptionCount = 0;\n      let goodDescriptionCount = 0;\n      let totalScore = 0;\n\n      for (const [, elements] of typeMap) {\n        const descs = elements.map((e: Element) => (e.description || \"\").trim()).filter((d: string) => d.length > 0);\n        let quality: \"empty\" | \"generic\" | \"good\";\n        if (descs.length === 0) {\n          quality = \"empty\";\n        } else {\n          const avgLen = descs.reduce((s: number, d: string) => s + d.length, 0) / descs.length;\n          quality = avgLen < 20 ? \"generic\" : \"good\";\n        }\n        if (quality === \"empty\") { emptyDescriptionCount++; totalScore += 0; }\n        else if (quality === \"generic\") { genericDescriptionCount++; totalScore += 30; }\n        else { goodDescriptionCount++; totalScore += 85; }\n      }\n\n      const totalNodeTypes = typeMap.size;\n      const avgQualityScore = totalNodeTypes > 0\n        ? Math.round((totalScore / totalNodeTypes) * 10) / 10\n        : 0;\n\n      return {\n        layerId,\n        totalNodeTypes,\n        avgQualityScore,\n        emptyDescriptionCount,\n        genericDescriptionCount,\n        goodDescriptionCount,\n        totalIssues: emptyDescriptionCount + genericDescriptionCount,\n        errorCount: 0,\n        warningCount: emptyDescriptionCount + genericDescriptionCount,\n      };\n    });\n\n    // Detect orphaned types: spec_node_ids in model that don't follow the\n    // expected \"{layer}.{type}\" naming convention\n    for (const [layerId, typeMap] of elementsByLayerAndType) {\n      for (const specNodeId of typeMap.keys()) {\n        // spec_node_id should start with \"{layerId}.\"\n        if (!specNodeId.startsWith(`${layerId}.`)) {\n          completenessIssues.push({\n            layerId,\n            specNodeId,\n            issueType: \"orphaned_schema\",\n            detail: `Element uses spec_node_id \"${specNodeId}\" which does not belong to layer \"${layerId}\"`,\n          });\n        }\n      }\n    }\n\n    const totalNodeTypes = [...elementsByLayerAndType.values()].reduce(\n      (sum, m) => sum + m.size,\n      0\n    );\n\n    if (options.verbose) {\n      process.stderr.write(\n        `Model node audit: ${filteredElements.length} elements, ${totalNodeTypes} unique types across ${elementsByLayerAndType.size} layers\\n`\n      );\n    }\n\n    return {\n      timestamp: new Date().toISOString(),\n      spec: {\n        version: model.manifest.version ?? \"1.0.0\",\n        totalNodeTypes,\n        totalLayers: elementsByLayerAndType.size,\n      },\n      layerSummaries,\n      definitionQuality: [],\n      overlaps: [],\n      completenessIssues,\n    };\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["totalNodeTypes"]
+}

package/dist/audit/nodes/spec/loader.js

@@ -0,0 +1,116 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join, basename, dirname } from "node:path";
+class NodeSchemaLoader {
+  specDir;
+  constructor(specDir) {
+    this.specDir = specDir;
+  }
+  /**
+   * Scan spec/schemas/nodes/{layer}/*.node.schema.json and parse each file.
+   * Optionally filter to a single layer by canonical name.
+   */
+  async loadAllSchemas(layerFilter) {
+    const nodesDir = join(this.specDir, "schemas", "nodes"), layerDirs = await readdir(nodesDir, { withFileTypes: !0 }), schemas = [];
+    for (const entry of layerDirs) {
+      if (!entry.isDirectory())
+        continue;
+      const layerName = entry.name;
+      if (layerFilter && layerName !== layerFilter)
+        continue;
+      const layerDir = join(nodesDir, layerName), files = await readdir(layerDir);
+      for (const file of files) {
+        if (!file.endsWith(".node.schema.json"))
+          continue;
+        const filePath = join(layerDir, file), raw = await readFile(filePath, "utf-8");
+        let json;
+        try {
+          json = JSON.parse(raw);
+        } catch {
+          continue;
+        }
+        const parsed = this.parseSchema(json, filePath);
+        parsed && schemas.push(parsed);
+      }
+    }
+    return schemas;
+  }
+  /**
+   * Read spec/layers/*.layer.json and return layer definitions.
+   */
+  async loadLayerDefinitions() {
+    const layersDir = join(this.specDir, "layers"), files = await readdir(layersDir), defs = [];
+    for (const file of files) {
+      if (!file.endsWith(".layer.json"))
+        continue;
+      const filePath = join(layersDir, file), raw = await readFile(filePath, "utf-8");
+      let json;
+      try {
+        json = JSON.parse(raw);
+      } catch (err) {
+        process.stderr.write(`warn: skipping malformed layer file ${filePath}: ${err}
+`);
+        continue;
+      }
+      defs.push(this.parseLayerDefinition(json));
+    }
+    return defs.sort((a, b) => a.number - b.number), defs;
+  }
+  /**
+   * Read spec/VERSION
+   */
+  async loadSpecVersion() {
+    const versionPath = join(this.specDir, "VERSION");
+    return (await readFile(versionPath, "utf-8")).trim();
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  parseSchema(json, filePath) {
+    const properties = json.properties;
+    if (!properties)
+      return null;
+    const specNodeId = this.extractConst(properties, "spec_node_id"), layerId = this.extractConst(properties, "layer_id"), typeName = this.extractConst(properties, "type");
+    if (!specNodeId || !layerId || !typeName) {
+      const fileName = basename(filePath, ".node.schema.json"), dirName = basename(dirname(filePath)), derivedLayerId = layerId ?? dirName, derivedTypeName = typeName ?? fileName, derivedSpecNodeId = specNodeId ?? `${derivedLayerId}.${derivedTypeName}`;
+      return this.buildParsedSchema(json, properties, filePath, derivedSpecNodeId, derivedLayerId, derivedTypeName);
+    }
+    return this.buildParsedSchema(json, properties, filePath, specNodeId, layerId, typeName);
+  }
+  buildParsedSchema(json, properties, filePath, specNodeId, layerId, typeName) {
+    const attributesProp = properties.attributes, attrProperties = attributesProp?.properties ?? {}, attrRequired = attributesProp?.required ?? [], attrAdditional = attributesProp?.additionalProperties ?? !1;
+    return {
+      specNodeId,
+      layerId,
+      typeName,
+      title: json.title ?? "",
+      description: json.description ?? "",
+      filePath,
+      attributes: {
+        properties: attrProperties,
+        required: attrRequired,
+        additionalProperties: attrAdditional
+      }
+    };
+  }
+  extractConst(properties, key) {
+    const prop = properties[key];
+    if (!prop)
+      return;
+    const constVal = prop.const;
+    return typeof constVal == "string" ? constVal : void 0;
+  }
+  parseLayerDefinition(json) {
+    const inspiredBy = json.inspired_by;
+    return {
+      id: json.id ?? "",
+      number: json.number ?? 0,
+      name: json.name ?? "",
+      nodeTypes: json.node_types ?? [],
+      inspiredBy: inspiredBy ? { standard: inspiredBy.standard, version: inspiredBy.version, url: inspiredBy.url } : void 0
+    };
+  }
+}
+export {
+  NodeSchemaLoader
+};
+//# sourceMappingURL=loader.js.map

package/dist/audit/nodes/spec/loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/spec/loader.ts"],
+  "sourcesContent": ["/**\n * Node schema loader \u2014 file I/O only.\n * Reads spec/ schema files and layer definitions from disk.\n */\n\nimport { readdir, readFile } from \"node:fs/promises\";\nimport { join, basename, dirname } from \"node:path\";\nimport type { ParsedNodeSchema, LayerDefinition } from \"../types.js\";\n\nexport class NodeSchemaLoader {\n  constructor(private readonly specDir: string) {}\n\n  /**\n   * Scan spec/schemas/nodes/{layer}/*.node.schema.json and parse each file.\n   * Optionally filter to a single layer by canonical name.\n   */\n  async loadAllSchemas(layerFilter?: string): Promise<ParsedNodeSchema[]> {\n    const nodesDir = join(this.specDir, \"schemas\", \"nodes\");\n    const layerDirs = await readdir(nodesDir, { withFileTypes: true });\n    const schemas: ParsedNodeSchema[] = [];\n\n    for (const entry of layerDirs) {\n      if (!entry.isDirectory()) continue;\n      const layerName = entry.name;\n      if (layerFilter && layerName !== layerFilter) continue;\n\n      const layerDir = join(nodesDir, layerName);\n      const files = await readdir(layerDir);\n\n      for (const file of files) {\n        if (!file.endsWith(\".node.schema.json\")) continue;\n        const filePath = join(layerDir, file);\n        const raw = await readFile(filePath, \"utf-8\");\n        let json: Record<string, unknown>;\n        try {\n          json = JSON.parse(raw) as Record<string, unknown>;\n        } catch {\n          // Skip unparseable files\n          continue;\n        }\n        const parsed = this.parseSchema(json, filePath);\n        if (parsed) schemas.push(parsed);\n      }\n    }\n\n    return schemas;\n  }\n\n  /**\n   * Read spec/layers/*.layer.json and return layer definitions.\n   */\n  async loadLayerDefinitions(): Promise<LayerDefinition[]> {\n    const layersDir = join(this.specDir, \"layers\");\n    const files = await readdir(layersDir);\n    const defs: LayerDefinition[] = [];\n\n    for (const file of files) {\n      if (!file.endsWith(\".layer.json\")) continue;\n      const filePath = join(layersDir, file);\n      const raw = await readFile(filePath, \"utf-8\");\n      let json: Record<string, unknown>;\n      try {\n        json = JSON.parse(raw) as Record<string, unknown>;\n      } catch (err) {\n        process.stderr.write(`warn: skipping malformed layer file ${filePath}: ${err}\\n`);\n        continue;\n      }\n      defs.push(this.parseLayerDefinition(json));\n    }\n\n    // Sort by layer number\n    defs.sort((a, b) => a.number - b.number);\n    return defs;\n  }\n\n  /**\n   * Read spec/VERSION\n   */\n  async loadSpecVersion(): Promise<string> {\n    const versionPath = join(this.specDir, \"VERSION\");\n    const content = await readFile(versionPath, \"utf-8\");\n    return content.trim();\n  }\n\n  // ---------------------------------------------------------------------------\n  // Private helpers\n  // ---------------------------------------------------------------------------\n\n  private parseSchema(\n    json: Record<string, unknown>,\n    filePath: string\n  ): ParsedNodeSchema | null {\n    // Extract spec_node_id, layer_id, type from properties.*.const\n    const properties = json[\"properties\"] as Record<string, unknown> | undefined;\n    if (!properties) return null;\n\n    const specNodeId = this.extractConst(properties, \"spec_node_id\");\n    const layerId = this.extractConst(properties, \"layer_id\");\n    const typeName = this.extractConst(properties, \"type\");\n\n    if (!specNodeId || !layerId || !typeName) {\n      // Fall back to deriving from file name\n      const fileName = basename(filePath, \".node.schema.json\");\n      const dirName = basename(dirname(filePath));\n      const derivedLayerId = layerId ?? dirName;\n      const derivedTypeName = typeName ?? fileName;\n      const derivedSpecNodeId = specNodeId ?? `${derivedLayerId}.${derivedTypeName}`;\n\n      return this.buildParsedSchema(json, properties, filePath, derivedSpecNodeId, derivedLayerId, derivedTypeName);\n    }\n\n    return this.buildParsedSchema(json, properties, filePath, specNodeId, layerId, typeName);\n  }\n\n  private buildParsedSchema(\n    json: Record<string, unknown>,\n    properties: Record<string, unknown>,\n    filePath: string,\n    specNodeId: string,\n    layerId: string,\n    typeName: string\n  ): ParsedNodeSchema {\n    const attributesProp = properties[\"attributes\"] as Record<string, unknown> | undefined;\n    const attrProperties = (attributesProp?.[\"properties\"] as Record<string, { type?: string; description?: string; format?: string; enum?: string[] }>) ?? {};\n    const attrRequired = (attributesProp?.[\"required\"] as string[]) ?? [];\n    const attrAdditional = (attributesProp?.[\"additionalProperties\"] as boolean) ?? false;\n\n    return {\n      specNodeId,\n      layerId,\n      typeName,\n      title: (json[\"title\"] as string) ?? \"\",\n      description: (json[\"description\"] as string) ?? \"\",\n      filePath,\n      attributes: {\n        properties: attrProperties,\n        required: attrRequired,\n        additionalProperties: attrAdditional,\n      },\n    };\n  }\n\n  private extractConst(properties: Record<string, unknown>, key: string): string | undefined {\n    const prop = properties[key] as Record<string, unknown> | undefined;\n    if (!prop) return undefined;\n    const constVal = prop[\"const\"];\n    return typeof constVal === \"string\" ? constVal : undefined;\n  }\n\n  private parseLayerDefinition(json: Record<string, unknown>): LayerDefinition {\n    const inspiredBy = json[\"inspired_by\"] as { standard: string; version: string; url?: string } | undefined;\n    return {\n      id: (json[\"id\"] as string) ?? \"\",\n      number: (json[\"number\"] as number) ?? 0,\n      name: (json[\"name\"] as string) ?? \"\",\n      nodeTypes: (json[\"node_types\"] as string[]) ?? [],\n      inspiredBy: inspiredBy\n        ? { standard: inspiredBy.standard, version: inspiredBy.version, url: inspiredBy.url }\n        : undefined,\n    };\n  }\n}\n"],
+  "mappings": "AAKA,SAAS,SAAS,gBAAgB;AAClC,SAAS,MAAM,UAAU,eAAe;AAGlC,MAAO,iBAAgB;EACE;EAA7B,YAA6B,SAAe;AAAf,SAAA,UAAA;EAAkB;;;;;EAM/C,MAAM,eAAe,aAAoB;AACvC,UAAM,WAAW,KAAK,KAAK,SAAS,WAAW,OAAO,GAChD,YAAY,MAAM,QAAQ,UAAU,EAAE,eAAe,GAAI,CAAE,GAC3D,UAA8B,CAAA;AAEpC,eAAW,SAAS,WAAW;AAC7B,UAAI,CAAC,MAAM,YAAW;AAAI;AAC1B,YAAM,YAAY,MAAM;AACxB,UAAI,eAAe,cAAc;AAAa;AAE9C,YAAM,WAAW,KAAK,UAAU,SAAS,GACnC,QAAQ,MAAM,QAAQ,QAAQ;AAEpC,iBAAW,QAAQ,OAAO;AACxB,YAAI,CAAC,KAAK,SAAS,mBAAmB;AAAG;AACzC,cAAM,WAAW,KAAK,UAAU,IAAI,GAC9B,MAAM,MAAM,SAAS,UAAU,OAAO;AAC5C,YAAI;AACJ,YAAI;AACF,iBAAO,KAAK,MAAM,GAAG;QACvB,QAAQ;AAEN;QACF;AACA,cAAM,SAAS,KAAK,YAAY,MAAM,QAAQ;AAC9C,QAAI,UAAQ,QAAQ,KAAK,MAAM;MACjC;IACF;AAEA,WAAO;EACT;;;;EAKA,MAAM,uBAAoB;AACxB,UAAM,YAAY,KAAK,KAAK,SAAS,QAAQ,GACvC,QAAQ,MAAM,QAAQ,SAAS,GAC/B,OAA0B,CAAA;AAEhC,eAAW,QAAQ,OAAO;AACxB,UAAI,CAAC,KAAK,SAAS,aAAa;AAAG;AACnC,YAAM,WAAW,KAAK,WAAW,IAAI,GAC/B,MAAM,MAAM,SAAS,UAAU,OAAO;AAC5C,UAAI;AACJ,UAAI;AACF,eAAO,KAAK,MAAM,GAAG;MACvB,SAAS,KAAK;AACZ,gBAAQ,OAAO,MAAM,uCAAuC,QAAQ,KAAK,GAAG;CAAI;AAChF;MACF;AACA,WAAK,KAAK,KAAK,qBAAqB,IAAI,CAAC;IAC3C;AAGA,gBAAK,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,GAChC;EACT;;;;EAKA,MAAM,kBAAe;AACnB,UAAM,cAAc,KAAK,KAAK,SAAS,SAAS;AAEhD,YADgB,MAAM,SAAS,aAAa,OAAO,GACpC,KAAI;EACrB;;;;EAMQ,YACN,MACA,UAAgB;AAGhB,UAAM,aAAa,KAAK;AACxB,QAAI,CAAC;AAAY,aAAO;AAExB,UAAM,aAAa,KAAK,aAAa,YAAY,cAAc,GACzD,UAAU,KAAK,aAAa,YAAY,UAAU,GAClD,WAAW,KAAK,aAAa,YAAY,MAAM;AAErD,QAAI,CAAC,cAAc,CAAC,WAAW,CAAC,UAAU;AAExC,YAAM,WAAW,SAAS,UAAU,mBAAmB,GACjD,UAAU,SAAS,QAAQ,QAAQ,CAAC,GACpC,iBAAiB,WAAW,SAC5B,kBAAkB,YAAY,UAC9B,oBAAoB,cAAc,GAAG,cAAc,IAAI,eAAe;AAE5E,aAAO,KAAK,kBAAkB,MAAM,YAAY,UAAU,mBAAmB,gBAAgB,eAAe;IAC9G;AAEA,WAAO,KAAK,kBAAkB,MAAM,YAAY,UAAU,YAAY,SAAS,QAAQ;EACzF;EAEQ,kBACN,MACA,YACA,UACA,YACA,SACA,UAAgB;AAEhB,UAAM,iBAAiB,WAAW,YAC5B,iBAAkB,gBAAiB,cAA+G,CAAA,GAClJ,eAAgB,gBAAiB,YAA4B,CAAA,GAC7D,iBAAkB,gBAAiB,wBAAuC;AAEhF,WAAO;MACL;MACA;MACA;MACA,OAAQ,KAAK,SAAuB;MACpC,aAAc,KAAK,eAA6B;MAChD;MACA,YAAY;QACV,YAAY;QACZ,UAAU;QACV,sBAAsB;;;EAG5B;EAEQ,aAAa,YAAqC,KAAW;AACnE,UAAM,OAAO,WAAW,GAAG;AAC3B,QAAI,CAAC;AAAM;AACX,UAAM,WAAW,KAAK;AACtB,WAAO,OAAO,YAAa,WAAW,WAAW;EACnD;EAEQ,qBAAqB,MAA6B;AACxD,UAAM,aAAa,KAAK;AACxB,WAAO;MACL,IAAK,KAAK,MAAoB;MAC9B,QAAS,KAAK,UAAwB;MACtC,MAAO,KAAK,QAAsB;MAClC,WAAY,KAAK,cAA8B,CAAA;MAC/C,YAAY,aACR,EAAE,UAAU,WAAW,UAAU,SAAS,WAAW,SAAS,KAAK,WAAW,IAAG,IACjF;;EAER;;",
+  "names": []
+}

package/dist/audit/nodes/spec/orchestrator.js

@@ -0,0 +1,68 @@
+import { NodeSchemaLoader } from "./loader.js";
+import { NodeDefinitionAnalyzer } from "../analysis/node-definition-analyzer.js";
+import { NodeOverlapDetector } from "../analysis/node-overlap-detector.js";
+import { NodeCompletenessChecker } from "../analysis/node-completeness-checker.js";
+import { NodeAIEvaluator } from "../ai/evaluator.js";
+class NodeAuditOrchestrator {
+  async runAudit(options) {
+    const loader = new NodeSchemaLoader(options.specDir), [specVersion, layerDefs, allSchemas] = await Promise.all([
+      loader.loadSpecVersion(),
+      loader.loadLayerDefinitions(),
+      loader.loadAllSchemas()
+    ]), schemas = options.layer ? allSchemas.filter((s) => s.layerId === options.layer) : allSchemas, definitionAnalyzer = new NodeDefinitionAnalyzer(), definitionQuality = schemas.map((s) => definitionAnalyzer.analyze(s)), overlaps = new NodeOverlapDetector().detectOverlaps(schemas), completenessIssues = new NodeCompletenessChecker().check(layerDefs, allSchemas).filter((issue) => !options.layer || issue.layerId === options.layer), qualityByLayer = groupQualityByLayer(definitionQuality), layerSummaries = layerDefs.filter((l) => !options.layer || l.id === options.layer).map((layerDef) => buildLayerSummary(layerDef.id, qualityByLayer.get(layerDef.id) ?? [])), report = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      spec: {
+        version: specVersion,
+        totalNodeTypes: allSchemas.length,
+        totalLayers: layerDefs.length
+      },
+      layerSummaries,
+      definitionQuality,
+      overlaps,
+      completenessIssues
+    };
+    if (options.enableAi) {
+      const schemasByLayer = /* @__PURE__ */ new Map();
+      for (const schema of allSchemas) {
+        const group = schemasByLayer.get(schema.layerId) ?? [];
+        group.push(schema), schemasByLayer.set(schema.layerId, group);
+      }
+      const filteredLayerDefs = layerDefs.filter((l) => !options.layer || l.id === options.layer), evaluator = new NodeAIEvaluator();
+      report.aiReviews = await evaluator.evaluateLayers(filteredLayerDefs, schemasByLayer);
+    }
+    return report;
+  }
+}
+function groupQualityByLayer(quality) {
+  const map = /* @__PURE__ */ new Map();
+  for (const q of quality) {
+    const group = map.get(q.layerId) ?? [];
+    group.push(q), map.set(q.layerId, group);
+  }
+  return map;
+}
+function buildLayerSummary(layerId, qualities) {
+  const total = qualities.length, avgScore = total > 0 ? qualities.reduce((sum, q) => sum + q.score, 0) / total : 0;
+  let emptyDescriptionCount = 0, genericDescriptionCount = 0, goodDescriptionCount = 0, errorCount = 0, warningCount = 0;
+  for (const q of qualities) {
+    q.descriptionQuality === "empty" ? emptyDescriptionCount++ : q.descriptionQuality === "generic" ? genericDescriptionCount++ : goodDescriptionCount++;
+    for (const issue of q.issues)
+      issue.severity === "error" ? errorCount++ : issue.severity === "warning" && warningCount++;
+  }
+  const totalIssues = qualities.reduce((sum, q) => sum + q.issues.length, 0);
+  return {
+    layerId,
+    totalNodeTypes: total,
+    avgQualityScore: Math.round(avgScore * 10) / 10,
+    emptyDescriptionCount,
+    genericDescriptionCount,
+    goodDescriptionCount,
+    totalIssues,
+    errorCount,
+    warningCount
+  };
+}
+export {
+  NodeAuditOrchestrator
+};
+//# sourceMappingURL=orchestrator.js.map

package/dist/audit/nodes/spec/orchestrator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/audit/nodes/spec/orchestrator.ts"],
+  "sourcesContent": ["/**\n * Node audit orchestrator.\n * Wires all analysis modules and returns a NodeAuditReport.\n */\n\nimport { NodeSchemaLoader } from \"./loader.js\";\nimport { NodeDefinitionAnalyzer } from \"../analysis/node-definition-analyzer.js\";\nimport { NodeOverlapDetector } from \"../analysis/node-overlap-detector.js\";\nimport { NodeCompletenessChecker } from \"../analysis/node-completeness-checker.js\";\nimport { NodeAIEvaluator } from \"../ai/evaluator.js\";\nimport type {\n  NodeAuditReport,\n  NodeLayerSummary,\n  NodeDefinitionQuality,\n  ParsedNodeSchema,\n} from \"../types.js\";\n\nexport interface NodeAuditOptions {\n  layer?: string;\n  verbose?: boolean;\n  specDir: string;\n  enableAi?: boolean;\n}\n\nexport class NodeAuditOrchestrator {\n  async runAudit(options: NodeAuditOptions): Promise<NodeAuditReport> {\n    const loader = new NodeSchemaLoader(options.specDir);\n\n    // 1. Load data \u2014 always load all schemas once, then filter in memory.\n    // This avoids a second disk scan when --layer is active and ensures\n    // completeness checking always runs against the full spec.\n    const [specVersion, layerDefs, allSchemas] = await Promise.all([\n      loader.loadSpecVersion(),\n      loader.loadLayerDefinitions(),\n      loader.loadAllSchemas(),\n    ]);\n\n    // Filtered view used by definition quality and overlap detection.\n    const schemas = options.layer\n      ? allSchemas.filter((s) => s.layerId === options.layer)\n      : allSchemas;\n\n    // 2. Definition quality \u2014 per schema\n    const definitionAnalyzer = new NodeDefinitionAnalyzer();\n    const definitionQuality: NodeDefinitionQuality[] = schemas.map((s) =>\n      definitionAnalyzer.analyze(s)\n    );\n\n    // 3. Overlap detection \u2014 per layer within the loaded schemas\n    const overlapDetector = new NodeOverlapDetector();\n    const overlaps = overlapDetector.detectOverlaps(schemas);\n\n    // 4. Completeness check \u2014 always against all schemas vs all layer defs,\n    // then filter to the requested layer so per-layer reports stay scoped.\n    const completenessChecker = new NodeCompletenessChecker();\n    const completenessIssues = completenessChecker\n      .check(layerDefs, allSchemas)\n      .filter((issue) => !options.layer || issue.layerId === options.layer);\n\n    // 5. Layer summaries\n    const qualityByLayer = groupQualityByLayer(definitionQuality);\n    const layerSummaries: NodeLayerSummary[] = layerDefs\n      .filter((l) => !options.layer || l.id === options.layer)\n      .map((layerDef) => buildLayerSummary(layerDef.id, qualityByLayer.get(layerDef.id) ?? []));\n\n    const report: NodeAuditReport = {\n      timestamp: new Date().toISOString(),\n      spec: {\n        version: specVersion,\n        totalNodeTypes: allSchemas.length,\n        totalLayers: layerDefs.length,\n      },\n      layerSummaries,\n      definitionQuality,\n      overlaps,\n      completenessIssues,\n    };\n\n    // 6. Optional AI step\n    if (options.enableAi) {\n      const schemasByLayer = new Map<string, ParsedNodeSchema[]>();\n      for (const schema of allSchemas) {\n        const group = schemasByLayer.get(schema.layerId) ?? [];\n        group.push(schema);\n        schemasByLayer.set(schema.layerId, group);\n      }\n      // Respect --layer filter: only evaluate the filtered layer defs\n      const filteredLayerDefs = layerDefs.filter(\n        (l) => !options.layer || l.id === options.layer\n      );\n      const evaluator = new NodeAIEvaluator();\n      report.aiReviews = await evaluator.evaluateLayers(filteredLayerDefs, schemasByLayer);\n    }\n\n    return report;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nfunction groupQualityByLayer(\n  quality: NodeDefinitionQuality[]\n): Map<string, NodeDefinitionQuality[]> {\n  const map = new Map<string, NodeDefinitionQuality[]>();\n  for (const q of quality) {\n    const group = map.get(q.layerId) ?? [];\n    group.push(q);\n    map.set(q.layerId, group);\n  }\n  return map;\n}\n\nfunction buildLayerSummary(\n  layerId: string,\n  qualities: NodeDefinitionQuality[]\n): NodeLayerSummary {\n  const total = qualities.length;\n  const avgScore = total > 0\n    ? qualities.reduce((sum, q) => sum + q.score, 0) / total\n    : 0;\n\n  let emptyDescriptionCount = 0;\n  let genericDescriptionCount = 0;\n  let goodDescriptionCount = 0;\n  let errorCount = 0;\n  let warningCount = 0;\n\n  for (const q of qualities) {\n    if (q.descriptionQuality === \"empty\") emptyDescriptionCount++;\n    else if (q.descriptionQuality === \"generic\") genericDescriptionCount++;\n    else goodDescriptionCount++;\n\n    for (const issue of q.issues) {\n      if (issue.severity === \"error\") errorCount++;\n      else if (issue.severity === \"warning\") warningCount++;\n    }\n  }\n\n  const totalIssues = qualities.reduce((sum, q) => sum + q.issues.length, 0);\n\n  return {\n    layerId,\n    totalNodeTypes: total,\n    avgQualityScore: Math.round(avgScore * 10) / 10,\n    emptyDescriptionCount,\n    genericDescriptionCount,\n    goodDescriptionCount,\n    totalIssues,\n    errorCount,\n    warningCount,\n  };\n}\n"],
+  "mappings": "AAKA,SAAS,wBAAwB;AACjC,SAAS,8BAA8B;AACvC,SAAS,2BAA2B;AACpC,SAAS,+BAA+B;AACxC,SAAS,uBAAuB;AAe1B,MAAO,sBAAqB;EAChC,MAAM,SAAS,SAAyB;AACtC,UAAM,SAAS,IAAI,iBAAiB,QAAQ,OAAO,GAK7C,CAAC,aAAa,WAAW,UAAU,IAAI,MAAM,QAAQ,IAAI;MAC7D,OAAO,gBAAe;MACtB,OAAO,qBAAoB;MAC3B,OAAO,eAAc;KACtB,GAGK,UAAU,QAAQ,QACpB,WAAW,OAAO,CAAC,MAAM,EAAE,YAAY,QAAQ,KAAK,IACpD,YAGE,qBAAqB,IAAI,uBAAsB,GAC/C,oBAA6C,QAAQ,IAAI,CAAC,MAC9D,mBAAmB,QAAQ,CAAC,CAAC,GAKzB,WADkB,IAAI,oBAAmB,EACd,eAAe,OAAO,GAKjD,qBADsB,IAAI,wBAAuB,EAEpD,MAAM,WAAW,UAAU,EAC3B,OAAO,CAAC,UAAU,CAAC,QAAQ,SAAS,MAAM,YAAY,QAAQ,KAAK,GAGhE,iBAAiB,oBAAoB,iBAAiB,GACtD,iBAAqC,UACxC,OAAO,CAAC,MAAM,CAAC,QAAQ,SAAS,EAAE,OAAO,QAAQ,KAAK,EACtD,IAAI,CAAC,aAAa,kBAAkB,SAAS,IAAI,eAAe,IAAI,SAAS,EAAE,KAAK,CAAA,CAAE,CAAC,GAEpF,SAA0B;MAC9B,YAAW,oBAAI,KAAI,GAAG,YAAW;MACjC,MAAM;QACJ,SAAS;QACT,gBAAgB,WAAW;QAC3B,aAAa,UAAU;;MAEzB;MACA;MACA;MACA;;AAIF,QAAI,QAAQ,UAAU;AACpB,YAAM,iBAAiB,oBAAI,IAAG;AAC9B,iBAAW,UAAU,YAAY;AAC/B,cAAM,QAAQ,eAAe,IAAI,OAAO,OAAO,KAAK,CAAA;AACpD,cAAM,KAAK,MAAM,GACjB,eAAe,IAAI,OAAO,SAAS,KAAK;MAC1C;AAEA,YAAM,oBAAoB,UAAU,OAClC,CAAC,MAAM,CAAC,QAAQ,SAAS,EAAE,OAAO,QAAQ,KAAK,GAE3C,YAAY,IAAI,gBAAe;AACrC,aAAO,YAAY,MAAM,UAAU,eAAe,mBAAmB,cAAc;IACrF;AAEA,WAAO;EACT;;AAOF,SAAS,oBACP,SAAgC;AAEhC,QAAM,MAAM,oBAAI,IAAG;AACnB,aAAW,KAAK,SAAS;AACvB,UAAM,QAAQ,IAAI,IAAI,EAAE,OAAO,KAAK,CAAA;AACpC,UAAM,KAAK,CAAC,GACZ,IAAI,IAAI,EAAE,SAAS,KAAK;EAC1B;AACA,SAAO;AACT;AAEA,SAAS,kBACP,SACA,WAAkC;AAElC,QAAM,QAAQ,UAAU,QAClB,WAAW,QAAQ,IACrB,UAAU,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,OAAO,CAAC,IAAI,QACjD;AAEJ,MAAI,wBAAwB,GACxB,0BAA0B,GAC1B,uBAAuB,GACvB,aAAa,GACb,eAAe;AAEnB,aAAW,KAAK,WAAW;AACzB,IAAI,EAAE,uBAAuB,UAAS,0BAC7B,EAAE,uBAAuB,YAAW,4BACxC;AAEL,eAAW,SAAS,EAAE;AACpB,MAAI,MAAM,aAAa,UAAS,eACvB,MAAM,aAAa,aAAW;EAE3C;AAEA,QAAM,cAAc,UAAU,OAAO,CAAC,KAAK,MAAM,MAAM,EAAE,OAAO,QAAQ,CAAC;AAEzE,SAAO;IACL;IACA,gBAAgB;IAChB,iBAAiB,KAAK,MAAM,WAAW,EAAE,IAAI;IAC7C;IACA;IACA;IACA;IACA;IACA;;AAEJ;",
+  "names": []
+}

package/dist/audit/nodes/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/audit/nodes/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/audit/pipeline/index.js

@@ -0,0 +1,5 @@
+import { PipelineOrchestrator } from "./pipeline-orchestrator.js";
+export {
+  PipelineOrchestrator
+};
+//# sourceMappingURL=index.js.map

package/dist/audit/pipeline/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/audit/pipeline/index.ts"],
+  "sourcesContent": ["export { PipelineOrchestrator, type PipelineOptions, type PipelineResult } from \"./pipeline-orchestrator.js\";\n"],
+  "mappings": "AAAA,SAAS,4BAAuE;",
+  "names": []
+}