@c4a/context-cli 0.5.38-beta.1 → 0.5.38-beta.3

package/cli.js

@@ -33106,18 +33106,76 @@ function renderSummaryText(value) {
 function escapeRawComment(value) {
   return value.replace(/-->/gu, "--\\>");
 }
-function renderRawBlock(section) {
+function renderRawBlock(section, renderedContent) {
   const raw = section.raw?.trim();
-  if (raw === undefined || raw.length === 0 || raw === section.content.trim())
+  if (raw === undefined || raw.length === 0 || raw === renderedContent.trim())
     return [];
   return ["", "<!-- c4a:raw", escapeRawComment(raw), "/c4a:raw -->"];
 }
-function renderSectionBody(section) {
+function plainHeadingText(value) {
+  return value.replace(/\[([^\]]+)\]\([^)]+\)/gu, "$1").replace(/`([^`]+)`/gu, "$1").replace(/\*\*([^*]+)\*\*/gu, "$1").replace(/\*([^*]+)\*/gu, "$1").replace(/_([^_]+)_/gu, "$1").replace(/<[^>]+>/gu, "").replace(/[ \t]+/gu, " ").trim().toLowerCase();
+}
+function collectHeadingLines(lines) {
+  const headings = [];
+  let fence;
+  for (const [index2, line] of lines.entries()) {
+    const fenceMatch = line.match(/^\s*(```|~~~)/u);
+    if (fenceMatch) {
+      const marker = fenceMatch[1];
+      fence = fence === undefined ? marker : fence === marker ? undefined : fence;
+      continue;
+    }
+    if (fence !== undefined)
+      continue;
+    const heading2 = line.match(/^(#{1,6})[ \t]+(.+?)(?:[ \t]+#+[ \t]*)?$/u);
+    if (!heading2)
+      continue;
+    headings.push({
+      index: index2,
+      level: heading2[1]?.length ?? 1,
+      text: heading2[2]?.trim() ?? ""
+    });
+  }
+  return headings;
+}
+function normalizeSectionContentHeadings(input) {
+  const trimmed = input.content.trim();
+  if (trimmed.length === 0)
+    return trimmed;
+  const lines = trimmed.split(/\r?\n/u);
+  const headings = collectHeadingLines(lines);
+  const removableTitleSet = new Set(input.removableTitles.map(plainHeadingText).filter((title) => title.length > 0));
+  const firstHeading = headings[0];
+  if (firstHeading !== undefined && removableTitleSet.has(plainHeadingText(firstHeading.text)) && lines.slice(0, firstHeading.index).every((line) => line.trim().length === 0)) {
+    lines.splice(firstHeading.index, 1);
+  }
+  const remainingHeadings = collectHeadingLines(lines);
+  const minDepth = remainingHeadings.reduce((current, heading2) => current === undefined ? heading2.level : Math.min(current, heading2.level), undefined);
+  const offset = minDepth === undefined ? 0 : Math.max(0, input.minHeadingLevel - minDepth);
+  if (offset === 0)
+    return lines.join(`
+`).trim();
+  const headingByLine = new Map(remainingHeadings.map((heading2) => [heading2.index, heading2]));
+  return lines.map((line, index2) => {
+    const heading2 = headingByLine.get(index2);
+    if (heading2 === undefined)
+      return line;
+    const level = Math.min(6, heading2.level + offset);
+    return `${"#".repeat(level)} ${heading2.text}`;
+  }).join(`
+`).trim();
+}
+function renderSectionBody(section, minHeadingLevel, groupTitle) {
+  const content3 = normalizeSectionContentHeadings({
+    content: section.content,
+    minHeadingLevel,
+    removableTitles: [section.summary ?? "", groupTitle]
+  });
   return [
     renderSectionComment(section),
     ...section.summary !== undefined ? ["<!-- c4a:summary -->", renderSummaryText(section.summary), "<!-- /c4a:summary -->", ""] : [],
-    section.content.trim(),
-    ...renderRawBlock(section),
+    content3,
+    ...renderRawBlock(section, content3),
     "<!-- /c4a:section -->"
   ].join(`
 `);
@@ -33140,7 +33198,7 @@ function renderSectionGroups(sections, headingLevel) {
     const groupSections2 = grouped.get(title) ?? [];
     if (groupSections2.length === 0)
       continue;
-    const renderedSections = groupSections2.map(renderSectionBody);
+    const renderedSections = groupSections2.map((section) => renderSectionBody(section, headingLevel + 1, title));
     parts.push([`${hashes} ${title}`, "", renderedSections.join(`
 
 `)].join(`
@@ -51606,12 +51664,34 @@ function isMeaningfulTerm(term) {
   return compacted.length >= 4;
 }
 function uniqueTerms(node3) {
-  return [...new Set([node3.slug, node3.title, ...node3.aliases ?? []].filter((term) => typeof term === "string").map((term) => term.trim()).filter(isMeaningfulTerm))];
+  const out2 = [];
+  const seen = new Set;
+  const push2 = (kind, term) => {
+    if (typeof term !== "string")
+      return;
+    const value = term.trim();
+    if (!isMeaningfulTerm(value))
+      return;
+    const key = `${kind}:${value}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    out2.push({ value, kind });
+  };
+  push2("slug", node3.slug);
+  push2("title", node3.title);
+  for (const alias of node3.aliases ?? [])
+    push2("alias", alias);
+  return out2;
 }
 function containsAsciiLikeTerm(text5, term) {
   const pattern = new RegExp(`(^|${ASCII_BOUNDARY})${escapeRegExp(term.toLowerCase())}($|${ASCII_BOUNDARY})`, "iu");
   return pattern.test(text5);
 }
+function containsAsciiLikeNameTerm(text5, term) {
+  const pattern = new RegExp(`(^|${ASCII_NAME_BOUNDARY})${escapeRegExp(term.toLowerCase())}($|${ASCII_NAME_BOUNDARY})`, "iu");
+  return pattern.test(text5);
+}
 function containsCjkTerm(text5, term) {
   const normalized = term.toLowerCase();
   let index2 = text5.indexOf(normalized);
@@ -51634,16 +51714,35 @@ function containsStrongTerm(text5, compactText, term) {
   const compacted = compact(normalized);
   return compacted.length >= 6 && compactText.includes(compacted);
 }
+function containsTerm(text5, compactText, term) {
+  if (term.kind === "slug")
+    return containsStrongTerm(text5, compactText, term.value);
+  const normalized = term.value.normalize("NFKC").toLowerCase();
+  if (CJK_RE2.test(normalized))
+    return containsCjkTerm(text5, normalized);
+  return containsAsciiLikeNameTerm(text5, normalized);
+}
+function currentCodePackage(input) {
+  return input.currentCodePackage ?? input.knownNodes.find((node3) => node3.slug === input.currentNodeSlug)?.codePackage;
+}
+function canInferFromTerm(input) {
+  if (input.term.kind === "slug")
+    return true;
+  if (input.currentCodePackage === undefined || input.targetCodePackage === undefined)
+    return true;
+  return input.currentCodePackage === input.targetCodePackage;
+}
 function inferRefersToNodes(input) {
   const existing = input.existing ?? [];
   const output = [...existing];
   const seen = new Set(output);
   const text5 = input.text.normalize("NFKC").toLowerCase();
   const compactText = compact(input.text);
+  const currentPackage = currentCodePackage(input);
   for (const node3 of input.knownNodes) {
     if (node3.slug === input.currentNodeSlug || seen.has(node3.slug))
       continue;
-    if (uniqueTerms(node3).some((term) => containsStrongTerm(text5, compactText, term))) {
+    if (uniqueTerms(node3).some((term) => canInferFromTerm({ term, currentCodePackage: currentPackage, targetCodePackage: node3.codePackage }) && containsTerm(text5, compactText, term))) {
       output.push(node3.slug);
       seen.add(node3.slug);
     }
@@ -51661,7 +51760,8 @@ async function collectKnownRefersToNodes(ctxDir) {
     bySlug.set(node3.parsed.node.id, {
       slug: node3.parsed.node.id,
       title: node3.parsed.node.title,
-      aliases: node3.parsed.node.aliases ?? []
+      aliases: node3.parsed.node.aliases ?? [],
+      ...node3.parsed.node.code_package !== undefined ? { codePackage: node3.parsed.node.code_package } : {}
     });
   }
   let activeSources = new Set;
@@ -51680,7 +51780,7 @@ async function collectKnownRefersToNodes(ctxDir) {
   }
   return [...bySlug.values()];
 }
-var ASCII_BOUNDARY = "[^\\p{Letter}\\p{Number}_]", CJK_RE2;
+var ASCII_BOUNDARY = "[^\\p{Letter}\\p{Number}_]", ASCII_NAME_BOUNDARY = "[^\\p{Letter}\\p{Number}_/-]", CJK_RE2;
 var init_refersToInference = __esm(() => {
   init_alignPlan();
   init_sources();
@@ -58354,11 +58454,12 @@ function sectionText(section) {
   return [section.summary, section.content, section.detail].filter((value) => typeof value === "string").join(`
 `);
 }
-async function withInferredRefersToNodes(ctxDir, nodeSlug, input) {
+async function withInferredRefersToNodes(ctxDir, nodeSlug, currentCodePackage2, input) {
   const inferred = inferRefersToNodes({
     text: [input.summary, input.content, input.detail].filter((value) => typeof value === "string").join(`
 `),
     currentNodeSlug: nodeSlug,
+    currentCodePackage: currentCodePackage2,
     knownNodes: await collectKnownRefersToNodes(ctxDir),
     existing: input.refers_to_nodes
   });
@@ -58366,7 +58467,7 @@ async function withInferredRefersToNodes(ctxDir, nodeSlug, input) {
 }
 async function mdriveSectionAdd(input) {
   const located = await locateNode(input.ctxDir, input.nodeSlug);
-  const sectionInput = await withInferredRefersToNodes(input.ctxDir, input.nodeSlug, input.input);
+  const sectionInput = await withInferredRefersToNodes(input.ctxDir, input.nodeSlug, located.parsed.node.code_package, input.input);
   const section = createSection(input.nodeSlug, sectionInput, nextSectionId(located.parsed.sections), located.parsed.node.type);
   reassignSections(located.parsed, [...located.parsed.sections, section]);
   await atomicRewriteRootFile(located.filePath, located.root);
@@ -58457,6 +58558,7 @@ async function mdriveSectionUpdate(input) {
     const inferred = inferRefersToNodes({
       text: sectionText(section),
       currentNodeSlug: input.nodeSlug,
+      currentCodePackage: located.parsed.node.code_package,
       knownNodes: await collectKnownRefersToNodes(input.ctxDir),
       existing: section.refers_to_nodes
     });
@@ -58492,7 +58594,7 @@ async function mdriveSectionSupersede(input) {
   const oldSection = findSection(input.nodeSlug, located.parsed, input.oldSectionId);
   oldSection.status = SectionStatus.deprecated;
   const nextId = nextSectionId(located.parsed.sections);
-  const sectionInput = await withInferredRefersToNodes(input.ctxDir, input.nodeSlug, input.input);
+  const sectionInput = await withInferredRefersToNodes(input.ctxDir, input.nodeSlug, located.parsed.node.code_package, input.input);
   const added = createSection(input.nodeSlug, sectionInput, nextId, located.parsed.node.type);
   added.relations = [
     ...added.relations ?? [],
@@ -98471,6 +98573,7 @@ function inferredRefersToNodes(input) {
   const inferred = inferRefersToNodes({
     text: input.text,
     currentNodeSlug: input.nodeSlug,
+    currentCodePackage: input.currentCodePackage,
     knownNodes: input.knownNodes,
     existing: input.existing
   });
@@ -98491,6 +98594,7 @@ function createProjectionSection(input) {
   const inferred = inferredRefersToNodes({
     knownNodes: input.knownNodes,
     nodeSlug: input.row.node_slug,
+    currentCodePackage: input.node.parsed.node.code_package,
     text: sectionText2(section)
   });
   if (inferred !== undefined)
@@ -98524,15 +98628,19 @@ function updateProjectionSection(input) {
     input.section.status = SectionStatus.active;
     changed = true;
   }
-  if (contentChanged) {
-    const inferred = inferredRefersToNodes({
-      knownNodes: input.knownNodes,
-      nodeSlug: input.row.node_slug,
-      text: sectionText2(input.section),
-      existing: input.section.refers_to_nodes
-    });
-    if (inferred !== undefined)
+  const inferred = inferredRefersToNodes({
+    knownNodes: input.knownNodes,
+    nodeSlug: input.row.node_slug,
+    currentCodePackage: input.node.parsed.node.code_package,
+    text: sectionText2(input.section)
+  });
+  if (JSON.stringify(input.section.refers_to_nodes ?? undefined) !== JSON.stringify(inferred)) {
+    if (inferred === undefined) {
+      delete input.section.refers_to_nodes;
+    } else {
       input.section.refers_to_nodes = inferred;
+    }
+    changed = true;
   }
   const issues = validateSection(input.section);
   if (issues.length > 0) {
@@ -98775,7 +98883,7 @@ function applyProjectableRows(input) {
       input.touchedNodes.add(node3);
       input.touchedFiles.add(node3.filePath);
       added += 1;
-    } else if (updateProjectionSection({ section: current.section, row, sourceRef, knownNodes: input.knownNodes })) {
+    } else if (updateProjectionSection({ section: current.section, node: node3, row, sourceRef, knownNodes: input.knownNodes })) {
       input.touchedNodes.add(node3);
       input.touchedFiles.add(node3.filePath);
       updated += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/context-cli",
-  "version": "0.5.38-beta.1",
+  "version": "0.5.38-beta.3",
   "type": "module",
   "bin": {
     "context": "./cli.js"

package/templates/aspect-runtime/aspectRunnerSdk.js

@@ -441,6 +441,12 @@ function cloneNode(node, children) {
     cloned.children = children;
   return cloned;
 }
+function cloneMarkdownNode(node) {
+  return {
+    ...node,
+    ...node.children !== undefined ? { children: node.children.map(cloneMarkdownNode) } : {}
+  };
+}
 function mdxAttrValueText(value) {
   if (value === null || value === undefined)
     return;
@@ -622,6 +628,14 @@ function plainText(node) {
     return node.value;
   return (node.children ?? []).map(plainText).join("");
 }
+function normalizedHeadingLabel(value) {
+  return compactWhitespace(value).toLowerCase();
+}
+function headingMatchesTitle(node, title) {
+  if (title === undefined || node.type !== "heading")
+    return false;
+  return normalizedHeadingLabel(plainText(node)) === normalizedHeadingLabel(title);
+}
 function firstHeadingText(nodes) {
   for (const node of nodes) {
     if (node.type === "heading") {
@@ -651,6 +665,56 @@ function stripYamlFrontmatter(raw) {
   }
   return raw;
 }
+function clampHeadingLevel(value) {
+  return Math.min(6, Math.max(1, Math.trunc(value)));
+}
+function minHeadingDepth(nodes) {
+  let out;
+  function visit(node) {
+    if (node.type === "heading" && typeof node.depth === "number") {
+      out = out === undefined ? node.depth : Math.min(out, node.depth);
+    }
+    for (const child of node.children ?? [])
+      visit(child);
+  }
+  for (const node of nodes)
+    visit(node);
+  return out;
+}
+function shiftHeadingDepths(nodes, offset) {
+  return nodes.map((node) => {
+    const next = cloneMarkdownNode(node);
+    if (next.type === "heading" && typeof next.depth === "number") {
+      next.depth = clampHeadingLevel(next.depth + offset);
+    }
+    if (next.children !== undefined) {
+      next.children = shiftHeadingDepths(next.children, offset);
+    }
+    return next;
+  });
+}
+function sectionBodyMarkdownFromTree(tree, options) {
+  const minHeadingLevel = clampHeadingLevel(options.minHeadingLevel ?? 3);
+  const removeTitleHeading = options.removeTitleHeading ?? true;
+  const children = (tree.children ?? []).map(cloneMarkdownNode);
+  const withoutTitle = removeTitleHeading && children[0] !== undefined && headingMatchesTitle(children[0], options.title) ? children.slice(1) : children;
+  const minDepth = minHeadingDepth(withoutTitle);
+  const headingOffset = minDepth === undefined ? 0 : Math.max(0, minHeadingLevel - minDepth);
+  return normalizeMarkdown(mdxProcessor.stringify({
+    ...tree,
+    children: shiftHeadingDepths(withoutTitle, headingOffset)
+  }));
+}
+function normalizeSectionMarkdown(markdown, options = {}) {
+  const source = stripYamlFrontmatter(markdown);
+  const tree = mdxProcessor.parse(source);
+  const normalized = mdxProcessor.runSync(tree);
+  const title = options.title ?? firstHeadingText(normalized.children ?? []);
+  return sectionBodyMarkdownFromTree(normalized, {
+    ...options,
+    ...title !== undefined ? { title } : {}
+  });
+}
 function parseMdxDocument(raw, fallbackTitle) {
   const source = stripYamlFrontmatter(raw);
   const tree = mdxProcessor.parse(source);
@@ -658,7 +722,8 @@ function parseMdxDocument(raw, fallbackTitle) {
   const markdown = normalizeMarkdown(mdxProcessor.stringify(normalized));
   const blocks = markdownBlocks(markdown);
   const title = firstHeadingText(normalized.children ?? []) ?? fallbackTitle;
-  return { title, markdown, blocks };
+  const bodyMarkdown = sectionBodyMarkdownFromTree(normalized, { title });
+  return { title, markdown, bodyMarkdown, blocks };
 }
 
 // src/aspect-runtime/index.ts
@@ -697,6 +762,7 @@ export {
   parseMdxDocument,
   parseJsLikeTokenNames,
   normalizeSymbolSlug,
+  normalizeSectionMarkdown,
   normalizeComponentSlug,
   markdownFence,
   inferComponentName,

package/templates/aspects/README.md

@@ -199,7 +199,7 @@ export default defineAspect({
         node_slug: "target-node",
         kind: "description",
         summary: doc.title,
-        content: doc.markdown,
+        content: doc.bodyMarkdown,
         source: file,
         artifact: artifactFromRelPath(file.path),
       });
@@ -208,6 +208,8 @@ export default defineAspect({
 });
 ```
 
+Use `doc.bodyMarkdown` for Section content. It removes a leading document title when it matches `doc.title`, then shifts remaining headings under the rendered Section container. The renderer applies the final heading offset again from the actual node depth, so nested child-node Sections stay structurally valid. `doc.markdown` remains available when a plugin needs the full normalized document.
+
 ---
 
 ## Section Projection Protocol (`section-projection.v2`)