kld-sdd 2.5.1 → 2.6.0

package/skywalk-sdd/ontology/artifact-parser.cjs

@@ -0,0 +1,621 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { DIAGNOSTIC_CODES, entityTypeForId } = require('./schema.cjs');
+const { ensureStructuralIdentities } = require('./structural-identity.cjs');
+
+const ENTITY_ID_PATTERN = /\b(?:CHG|CAP|STMT|AC|CON|DES|TASK|ART|SEC|SNAP)-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/gi;
+const IDENTITY_META_PATTERN = /^\s*-\s+\*\*(entity-id|version-id|predecessor-version|delta-state)\*\*\s*[：:]\s*(.*?)\s*$/i;
+
+function toPosix(value) {
+  return String(value || '').replace(/\\/g, '/');
+}
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+function safeChangeName(changeName) {
+  const value = String(changeName || '').trim();
+  if (!value || !/^[A-Za-z0-9._-]+$/.test(value) || value === '.' || value === '..') {
+    throw new Error(`change 名称不安全: ${changeName}`);
+  }
+  return value;
+}
+
+function stripInlineYamlComment(value) {
+  const input = String(value || '');
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < input.length; index += 1) {
+    const char = input[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === '\\' && quote === '"') {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = '';
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === '#' && (index === 0 || /\s/.test(input[index - 1]))) {
+      return input.slice(0, index).trimEnd();
+    }
+  }
+  return input.trimEnd();
+}
+
+function unwrapScalar(value) {
+  let normalized = String(value || '').trim();
+  if ((normalized.startsWith('"') && normalized.endsWith('"'))
+    || (normalized.startsWith("'") && normalized.endsWith("'"))
+    || (normalized.startsWith('`') && normalized.endsWith('`'))) {
+    normalized = normalized.slice(1, -1).trim();
+  }
+  return normalized;
+}
+
+function parseFrontmatter(lines) {
+  const result = {};
+  if (!lines.length || lines[0].trim() !== '---') return result;
+  for (let index = 1; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    if (line.trim() === '---') break;
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
+    if (!match) continue;
+    const value = unwrapScalar(stripInlineYamlComment(match[2]));
+    result[match[1].toLowerCase()] = value;
+  }
+  return result;
+}
+
+function scanArtifactFiles(changeDir) {
+  const files = [];
+  if (!fs.existsSync(changeDir)) return files;
+
+  function walk(current) {
+    for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+      if (entry.name.startsWith('.') || entry.name === 'reports' || entry.name === 'logs') continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (/^(proposal|spec|design|tasks?)\.md$/i.test(entry.name)) {
+        const content = fs.readFileSync(full, 'utf8').replace(/^\uFEFF/, '');
+        files.push({
+          absolutePath: full,
+          relativePath: toPosix(path.relative(changeDir, full)),
+          content,
+          contentHash: sha256(content),
+        });
+      }
+    }
+  }
+
+  walk(changeDir);
+  return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+
+function artifactType(relativePath) {
+  const name = path.posix.basename(toPosix(relativePath)).toLowerCase();
+  if (name === 'proposal.md') return 'proposal';
+  if (name === 'spec.md') return 'spec';
+  if (name === 'design.md') return 'design';
+  if (name === 'tasks.md' || name === 'task.md') return 'tasks';
+  if (name === 'effective-spec.md') return 'projection';
+  return 'unknown';
+}
+
+function sourceFor(file, line, anchorId) {
+  return {
+    artifact_type: artifactType(file.relativePath),
+    file: file.relativePath,
+    line,
+    anchor_id: anchorId,
+    content_hash: file.contentHash,
+  };
+}
+
+function addEntity(target, type, id, name, file, line, attributes = {}, identity = {}, semanticContent = '') {
+  const anchorId = String(id || '').toUpperCase();
+  const entity = {
+    id: anchorId,
+    anchor_id: anchorId,
+    type,
+    name: String(name || '').trim(),
+    entity_id: String(identity.entity_id || '').trim().toLowerCase() || undefined,
+    version_id: String(identity.version_id || '').trim().toLowerCase() || undefined,
+    predecessor_version_id: String(identity.predecessor_version_id || '').trim().toLowerCase() || undefined,
+    delta_state: String(identity.delta_state || '').trim().toLowerCase() || undefined,
+    content_hash: sha256(stripIdentityMetadata(semanticContent || `${type}\n${anchorId}\n${name}`)),
+    attributes,
+    source: sourceFor(file, line, anchorId),
+  };
+  target.entities.push(entity);
+  return entity;
+}
+
+function addRelation(target, type, from, to, file, line, assertionType = 'asserted', ruleId = '') {
+  target.relations.push({
+    type,
+    from: String(from || '').toUpperCase(),
+    to: String(to || '').toUpperCase(),
+    assertion_type: assertionType,
+    rule_id: ruleId || undefined,
+    source: sourceFor(file, line, `${String(from || '').toUpperCase()}-${type}-${String(to || '').toUpperCase()}`),
+  });
+}
+
+function extractIds(value) {
+  return (String(value || '').match(ENTITY_ID_PATTERN) || []).map((id) => id.toUpperCase());
+}
+
+function stripIdentityMetadata(value) {
+  return String(value || '')
+    .split('\n')
+    .filter((line) => !IDENTITY_META_PATTERN.test(line))
+    .filter((line) => !/^\s*(?:entity-id|version-id|predecessor-version|delta-state)\s*:/i.test(line))
+    .filter((line) => !/^\s*-\s+\*\*(?:realizes|implements|covers|dependsOn|constrains|约束对象|实现需求|覆盖需求|依赖)\*\*\s*[：:]/i.test(line))
+    .join('\n')
+    .trim();
+}
+
+function identityFromValues(values = {}) {
+  const optionalValue = (value) => {
+    const normalized = String(value || '').trim();
+    return /^(?:无|none|null|-)$/i.test(normalized) ? '' : normalized;
+  };
+  return {
+    entity_id: optionalValue(values['entity-id']),
+    version_id: optionalValue(values['version-id']),
+    predecessor_version_id: optionalValue(values['predecessor-version']),
+    delta_state: String(values['delta-state'] || '').trim(),
+  };
+}
+
+function parseIdentityBlock(lines, startIndex, endIndex = lines.length) {
+  const values = {};
+  let started = false;
+  for (let index = startIndex; index < endIndex; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    if (!line.trim() && !started) continue;
+    const match = line.match(IDENTITY_META_PATTERN);
+    if (!match) break;
+    started = true;
+    values[match[1].toLowerCase()] = unwrapScalar(match[2]);
+  }
+  return identityFromValues(values);
+}
+
+function headingLevel(line) {
+  const match = String(line || '').match(/^\s*(#{1,6})\s+/);
+  return match ? match[1].length : 0;
+}
+
+function sectionEnd(lines, startIndex, level) {
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    const nextLevel = headingLevel(lines[index]);
+    if (nextLevel > 0 && nextLevel <= level) return index;
+  }
+  return lines.length;
+}
+
+function statementContentEnd(lines, startIndex) {
+  const endIndex = sectionEnd(lines, startIndex, 4);
+  for (let index = startIndex + 1; index < endIndex; index += 1) {
+    if (/^\s*#####\s+场景[：:]/i.test(lines[index])) return index;
+  }
+  return endIndex;
+}
+
+function parseProposal(target, file, lines, frontmatter) {
+  target.proposalMode = String(frontmatter.mode || '').trim().toLowerCase();
+  const changeId = String(frontmatter['change-id'] || '').trim().toUpperCase();
+  if (changeId) {
+    addEntity(
+      target,
+      'Change',
+      changeId,
+      target.changeName,
+      file,
+      1,
+      { change_name: target.changeName },
+      identityFromValues(frontmatter),
+      file.content,
+    );
+    target.changeId = changeId;
+  } else {
+    target.diagnostics.push({
+      code: DIAGNOSTIC_CODES.ID_MISSING,
+      severity: 'warning',
+      message: 'proposal.md 缺少 change-id；旧产物保持可读，但不推导稳定 Change 身份',
+      file: file.relativePath,
+      line: 1,
+    });
+  }
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    const match = line.match(/^\s*-\s+(?:\[[ xX]\]\s+)?\[(CAP-[A-Z0-9-]+)\]\s+(`?[A-Za-z0-9._-]+`?)\s*:\s*(.+?)\s*$/i);
+    if (!match) continue;
+    const capabilityId = match[1].toUpperCase();
+    const identity = parseIdentityBlock(lines, index + 1);
+    const slug = unwrapScalar(match[2]);
+    addEntity(target, 'Capability', capabilityId, slug, file, index + 1, {
+      slug,
+      description: match[3],
+    }, identity, line);
+    if (target.changeId) {
+      addRelation(target, 'contains', target.changeId, capabilityId, file, index + 1, 'inferred', 'proposal-capability-membership');
+    }
+  }
+}
+
+function parseSpec(target, file, lines, frontmatter) {
+  const capabilityId = String(frontmatter['capability-id'] || '').trim().toUpperCase();
+  let currentStatement = '';
+  let currentConstraint = '';
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    let inheritedMatch = line.match(/^\s*-\s+\*\*anchor\*\*\s*[：:]\s*`?((?:STMT|AC|CON)-[A-Z0-9-]+)`?\s*$/i);
+    if (inheritedMatch) {
+      const anchorId = inheritedMatch[1].toUpperCase();
+      const identity = parseIdentityBlock(lines, index + 1);
+      let source = '';
+      let sourceVersionHash = '';
+      for (let offset = index + 1; offset < Math.min(lines.length, index + 10); offset += 1) {
+        if (headingLevel(lines[offset]) > 0) break;
+        const sourceMatch = lines[offset].match(/^\s*-\s+\*\*source\*\*\s*[：:]\s*(.*?)\s*$/i);
+        const hashMatch = lines[offset].match(/^\s*-\s+\*\*source-version-hash\*\*\s*[：:]\s*`?([a-f0-9]{64})`?\s*$/i);
+        if (sourceMatch) source = unwrapScalar(sourceMatch[1]);
+        if (hashMatch) sourceVersionHash = hashMatch[1].toLowerCase();
+      }
+      target.inheritedReferences.push({
+        anchor_id: anchorId,
+        type: entityTypeForId(anchorId),
+        entity_id: String(identity.entity_id || '').toLowerCase() || undefined,
+        version_id: String(identity.version_id || '').toLowerCase() || undefined,
+        delta_state: String(identity.delta_state || '').toLowerCase() || undefined,
+        source_ref: source || undefined,
+        source_version_hash: sourceVersionHash || undefined,
+        source: sourceFor(file, index + 1, anchorId),
+      });
+      continue;
+    }
+    const inheritedRelationMatch = line.match(/^\s*-\s+\*\*relation\*\*\s*[：:]\s*`?((?:CHG|CAP|STMT|AC|CON|DES|TASK)-[A-Z0-9-]+)\s+(contains|acceptedBy|constrainedBy|realizes|implements|covers|dependsOn)\s+((?:CHG|CAP|STMT|AC|CON|DES|TASK)-[A-Z0-9-]+)`?\s*$/i);
+    if (inheritedRelationMatch) {
+      let source = '';
+      for (let offset = index + 1; offset < Math.min(lines.length, index + 6); offset += 1) {
+        if (headingLevel(lines[offset]) > 0) break;
+        const sourceMatch = lines[offset].match(/^\s*-\s+\*\*source\*\*\s*[：:]\s*(.*?)\s*$/i);
+        if (sourceMatch) source = unwrapScalar(sourceMatch[1]);
+      }
+      target.inheritedRelations.push({
+        type: inheritedRelationMatch[2],
+        from: inheritedRelationMatch[1].toUpperCase(),
+        to: inheritedRelationMatch[3].toUpperCase(),
+        source_ref: source || undefined,
+        source: sourceFor(file, index + 1, `${inheritedRelationMatch[1]}-${inheritedRelationMatch[2]}-${inheritedRelationMatch[3]}`),
+      });
+      continue;
+    }
+    let match = line.match(/^\s*####\s+需求项[：:]\s*[【\[]?(STMT-[A-Z0-9-]+)[】\]]?\s*(.*?)\s*$/i);
+    if (match) {
+      currentStatement = match[1].toUpperCase();
+      currentConstraint = '';
+      const endIndex = sectionEnd(lines, index, 4);
+      const contentEndIndex = statementContentEnd(lines, index);
+      addEntity(
+        target,
+        'SpecificationStatement',
+        currentStatement,
+        match[2],
+        file,
+        index + 1,
+        { capability_id: capabilityId || undefined },
+        parseIdentityBlock(lines, index + 1, endIndex),
+        lines.slice(index, contentEndIndex).join('\n'),
+      );
+      if (capabilityId) {
+        addRelation(target, 'contains', capabilityId, currentStatement, file, index + 1, 'inferred', 'spec-capability-membership');
+      }
+      continue;
+    }
+
+    match = line.match(/^\s*#####\s+场景[：:]\s*[【\[]?(AC-[A-Z0-9-]+)[】\]]?\s*(.*?)\s*$/i);
+    if (match) {
+      const acceptanceId = match[1].toUpperCase();
+      const endIndex = sectionEnd(lines, index, 5);
+      addEntity(
+        target,
+        'AcceptanceCriterion',
+        acceptanceId,
+        match[2],
+        file,
+        index + 1,
+        { statement_id: currentStatement || undefined },
+        parseIdentityBlock(lines, index + 1, endIndex),
+        lines.slice(index, endIndex).join('\n'),
+      );
+      if (currentStatement) {
+        addRelation(target, 'acceptedBy', currentStatement, acceptanceId, file, index + 1, 'inferred', 'nested-acceptance-scenario');
+      }
+      continue;
+    }
+
+    match = line.match(/^\s*####\s+约束[：:]\s*[【\[]?(CON-[A-Z0-9-]+)[】\]]?\s*(.*?)\s*$/i);
+    if (match) {
+      currentConstraint = match[1].toUpperCase();
+      currentStatement = '';
+      const endIndex = sectionEnd(lines, index, 4);
+      addEntity(
+        target,
+        'Constraint',
+        currentConstraint,
+        match[2],
+        file,
+        index + 1,
+        { capability_id: capabilityId || undefined },
+        parseIdentityBlock(lines, index + 1, endIndex),
+        lines.slice(index, endIndex).join('\n'),
+      );
+      continue;
+    }
+
+    match = line.match(/^\s*-\s+\*\*(?:constrains|约束对象)\*\*\s*[：:]\s*(.*?)\s*$/i);
+    if (match && currentConstraint) {
+      for (const statementId of extractIds(match[1]).filter((id) => id.startsWith('STMT-'))) {
+        addRelation(target, 'constrainedBy', statementId, currentConstraint, file, index + 1);
+      }
+    }
+  }
+}
+
+function parseDesign(target, file, lines, frontmatter) {
+  const capabilityId = String(frontmatter['capability-id'] || '').trim().toUpperCase();
+  let currentDesign = '';
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    let match = line.match(/^\s*#{2,5}\s+\[(DES-[A-Z0-9-]+)\]\s*(.*?)\s*$/i);
+    if (match) {
+      currentDesign = match[1].toUpperCase();
+      const endIndex = sectionEnd(lines, index, headingLevel(line));
+      addEntity(
+        target,
+        'DesignElement',
+        currentDesign,
+        match[2],
+        file,
+        index + 1,
+        { capability_id: capabilityId || undefined },
+        parseIdentityBlock(lines, index + 1, endIndex),
+        lines.slice(index, endIndex).join('\n'),
+      );
+      continue;
+    }
+    match = line.match(/^\s*-\s+\*\*(?:realizes|实现需求)\*\*\s*[：:]\s*(.*?)\s*$/i);
+    if (match && currentDesign) {
+      for (const statementId of extractIds(match[1]).filter((id) => id.startsWith('STMT-'))) {
+        addRelation(target, 'realizes', currentDesign, statementId, file, index + 1);
+      }
+    }
+  }
+}
+
+function parseTasks(target, file, lines, frontmatter) {
+  const capabilityId = String(frontmatter['capability-id'] || '').trim().toUpperCase();
+  let currentTask = '';
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].replace(/\r$/, '');
+    let match = line.match(/^\s*#{2,5}\s+\[(TASK-[A-Z0-9-]+)\]\s*(.*?)\s*$/i);
+    if (match) {
+      currentTask = match[1].toUpperCase();
+      const endIndex = sectionEnd(lines, index, headingLevel(line));
+      addEntity(
+        target,
+        'Task',
+        currentTask,
+        match[2],
+        file,
+        index + 1,
+        { capability_id: capabilityId || undefined },
+        parseIdentityBlock(lines, index + 1, endIndex),
+        lines.slice(index, endIndex).join('\n'),
+      );
+      continue;
+    }
+    match = line.match(/^\s*-\s+\*\*(implements|covers|dependsOn|实现设计|覆盖需求|依赖)\*\*\s*[：:]\s*(.*?)\s*$/i);
+    if (!match || !currentTask) continue;
+    const relationName = match[1].toLowerCase();
+    const type = relationName === 'implements' || relationName === '实现设计'
+      ? 'implements'
+      : relationName === 'covers' || relationName === '覆盖需求'
+        ? 'covers'
+        : 'dependsOn';
+    for (const targetId of extractIds(match[2])) {
+      addRelation(target, type, currentTask, targetId, file, index + 1);
+    }
+  }
+}
+
+function inferProfile(files, proposalMode = '', diagnostics = []) {
+  const normalizedMode = String(proposalMode || '').trim().toLowerCase();
+  if (normalizedMode === 'simple' || normalizedMode === 'full') return normalizedMode;
+  const fullLayout = files.some((file) => /^specs\/[^/]+\/(?:spec|design|tasks?)\.md$/i.test(file.relativePath));
+  if (normalizedMode) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.PROFILE_INVALID,
+      severity: 'error',
+      message: `proposal.md mode 非法: ${proposalMode}`,
+      file: 'proposal.md',
+      line: 1,
+    });
+  } else {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.PROFILE_INFERRED,
+      severity: 'warning',
+      message: 'proposal.md 缺少 mode，已按旧产物目录形态推断 profile',
+      file: 'proposal.md',
+      line: 1,
+    });
+  }
+  return fullLayout ? 'full' : 'simple';
+}
+
+function structuralAnchor(prefix, key) {
+  return `${prefix}-${sha256(key).slice(0, 16).toUpperCase()}`;
+}
+
+function addStructuralEntities(target, files, options = {}) {
+  const businessEntities = target.entities.slice();
+  const descriptors = [];
+  const changeScope = target.changeId || target.changeName;
+  for (const file of files) {
+    const key = `artifact:${changeScope}:${file.relativePath}`;
+    descriptors.push({
+      key,
+      anchor_id: structuralAnchor('ART', key),
+      type: 'Artifact',
+      content_hash: file.contentHash,
+      file,
+    });
+  }
+  for (const entity of businessEntities) {
+    const key = `section:${changeScope}:${entity.source.file}#${entity.id}`;
+    descriptors.push({
+      key,
+      anchor_id: structuralAnchor('SEC', key),
+      type: 'DocumentSection',
+      content_hash: entity.content_hash,
+      entity,
+    });
+  }
+
+  const registry = ensureStructuralIdentities(target.changeDir, descriptors, {
+    persist: options.persistStructuralIdentities !== false,
+  });
+  const artifactByFile = new Map();
+  const sectionByEntity = new Map();
+  for (const descriptor of descriptors) {
+    const identity = registry.identities[descriptor.key];
+    if (!identity) continue;
+    if (descriptor.type === 'Artifact') {
+      const artifact = {
+        id: identity.anchor_id,
+        anchor_id: identity.anchor_id,
+        type: 'Artifact',
+        name: descriptor.file.relativePath,
+        entity_id: identity.entity_id,
+        version_id: identity.version_id,
+        delta_state: 'added',
+        content_hash: descriptor.content_hash,
+        attributes: { artifact_type: artifactType(descriptor.file.relativePath), path: descriptor.file.relativePath },
+        source: sourceFor(descriptor.file, 1, identity.anchor_id),
+      };
+      target.entities.push(artifact);
+      artifactByFile.set(descriptor.file.relativePath, artifact);
+    } else {
+      const owner = descriptor.entity;
+      const section = {
+        id: identity.anchor_id,
+        anchor_id: identity.anchor_id,
+        type: 'DocumentSection',
+        name: `${owner.source.file}#${owner.id}`,
+        entity_id: identity.entity_id,
+        version_id: identity.version_id,
+        delta_state: 'added',
+        content_hash: descriptor.content_hash,
+        attributes: { artifact_path: owner.source.file, entity_anchor: owner.id },
+        source: { ...owner.source, anchor_id: identity.anchor_id },
+      };
+      target.entities.push(section);
+      sectionByEntity.set(owner.id, section);
+    }
+  }
+
+  const filesByPath = new Map(files.map((file) => [file.relativePath, file]));
+  for (const entity of businessEntities) {
+    const artifact = artifactByFile.get(entity.source.file);
+    const section = sectionByEntity.get(entity.id);
+    const file = filesByPath.get(entity.source.file);
+    if (artifact && file) addRelation(target, 'declares', artifact.id, entity.id, file, entity.source.line);
+    if (section && file) addRelation(target, 'sourcedFrom', entity.id, section.id, file, entity.source.line);
+  }
+}
+
+function parseChangeArtifacts(projectRoot, changeName, options = {}) {
+  const normalizedRoot = path.resolve(projectRoot || process.cwd());
+  const safeName = safeChangeName(changeName);
+  const changeDir = options.changeDir
+    ? path.resolve(options.changeDir)
+    : path.join(normalizedRoot, 'openspec', 'changes', safeName);
+  if (!fs.existsSync(changeDir)) {
+    throw new Error(`变更目录不存在: ${changeDir}`);
+  }
+
+  const files = scanArtifactFiles(changeDir);
+  const target = {
+    projectRoot: normalizedRoot,
+    changeDir,
+    changeName: safeName,
+    changeId: '',
+    profile: 'simple',
+    proposalMode: '',
+    artifacts: [],
+    files: files.map((file) => ({ path: file.relativePath, content_hash: file.contentHash })),
+    entities: [],
+    relations: [],
+    inheritedReferences: [],
+    inheritedRelations: [],
+    diagnostics: [],
+  };
+
+  for (const file of files) {
+    const type = artifactType(file.relativePath);
+    const lines = file.content.split('\n');
+    const frontmatter = parseFrontmatter(lines);
+    target.artifacts.push({
+      type,
+      path: file.relativePath,
+      content_hash: file.contentHash,
+      capability_id: String(frontmatter['capability-id'] || '').trim().toUpperCase() || undefined,
+    });
+    if (type === 'proposal') parseProposal(target, file, lines, frontmatter);
+    if (type === 'spec') parseSpec(target, file, lines, frontmatter);
+    if (type === 'design') parseDesign(target, file, lines, frontmatter);
+    if (type === 'tasks') parseTasks(target, file, lines, frontmatter);
+  }
+
+  target.profile = inferProfile(files, target.proposalMode, target.diagnostics);
+  addStructuralEntities(target, files, options);
+
+  return target;
+}
+
+module.exports = {
+  ENTITY_ID_PATTERN,
+  safeChangeName,
+  stripInlineYamlComment,
+  unwrapScalar,
+  parseFrontmatter,
+  scanArtifactFiles,
+  artifactType,
+  extractIds,
+  stripIdentityMetadata,
+  parseIdentityBlock,
+  sectionEnd,
+  statementContentEnd,
+  inferProfile,
+  structuralAnchor,
+  addStructuralEntities,
+  parseChangeArtifacts,
+};