@fulmenhq/tsfulmen 0.3.3 → 0.4.1

package/dist/chunk-BCO3FUUO.js

@@ -0,0 +1,682 @@
+import { parseDocument } from 'yaml';
+
+// src/docscribe/frontmatter.ts
+
+// src/docscribe/normalize.ts
+var decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+function stripBom(value) {
+  return value.charCodeAt(0) === 65279 ? value.slice(1) : value;
+}
+function normalizeNewlines(value) {
+  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function normalizeInput(input) {
+  let content;
+  if (typeof input === "string") {
+    content = input;
+  } else if (input instanceof Uint8Array) {
+    content = decoder.decode(input);
+  } else {
+    content = decoder.decode(new Uint8Array(input));
+  }
+  const normalized = normalizeNewlines(stripBom(content));
+  return { content: normalized, original: input };
+}
+
+// src/docscribe/types.ts
+var DocScribeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "DocScribeError";
+  }
+};
+var DocScribeParseError = class extends DocScribeError {
+  constructor(message, options) {
+    super(message, options);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "DocScribeParseError";
+  }
+};
+var DocScribeUnsupportedFormatError = class extends DocScribeError {
+  constructor(message, options) {
+    super(message, options);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "DocScribeUnsupportedFormatError";
+  }
+};
+
+// src/docscribe/frontmatter.ts
+var FRONTMATTER_DELIMITER = "---";
+var STRING_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "author",
+  "date",
+  "lastUpdated",
+  "status",
+  "version"
+]);
+function parseFrontmatter(input) {
+  const { content } = normalizeInput(input);
+  const bounds = locateFrontmatter(content);
+  if (!bounds) {
+    return { metadata: null, body: content, range: null, bodyStartLine: 1 };
+  }
+  const yamlBlock = content.slice(bounds.openEnd, bounds.closingStart);
+  const metadata = yamlBlock.trim().length === 0 ? {} : parseYamlMetadata(yamlBlock);
+  const bodyRaw = content.slice(bounds.closingEnd);
+  const leadingNewlinesMatch = bodyRaw.match(/^\n+/);
+  const leadingNewlinesLength = leadingNewlinesMatch ? leadingNewlinesMatch[0].length : 0;
+  const bodyStartIndex = bounds.closingEnd + leadingNewlinesLength;
+  const prefix = content.slice(0, bodyStartIndex);
+  const bodyStartLine = prefix.length === 0 ? 1 : prefix.split("\n").length;
+  const body = bodyRaw.slice(leadingNewlinesLength);
+  return {
+    metadata,
+    body,
+    range: { start: bounds.start, end: bounds.closingEnd },
+    bodyStartLine
+  };
+}
+function stripFrontmatter(input) {
+  return parseFrontmatter(input).body;
+}
+function extractMetadata(input) {
+  return parseFrontmatter(input).metadata;
+}
+function locateFrontmatter(content) {
+  let cursor = 0;
+  while (cursor < content.length) {
+    const newlineIndex = content.indexOf("\n", cursor);
+    const lineEnd = newlineIndex === -1 ? content.length : newlineIndex;
+    const line = content.slice(cursor, lineEnd);
+    if (line.trim().length === 0) {
+      if (newlineIndex === -1) {
+        return null;
+      }
+      cursor = newlineIndex + 1;
+      continue;
+    }
+    if (line.trim() !== FRONTMATTER_DELIMITER) {
+      return null;
+    }
+    const openStart = cursor;
+    const openEnd = newlineIndex === -1 ? content.length : newlineIndex + 1;
+    let search = openEnd;
+    while (search <= content.length) {
+      const nextNewline = content.indexOf("\n", search);
+      const segmentEnd = nextNewline === -1 ? content.length : nextNewline;
+      const candidate = content.slice(search, segmentEnd).trim();
+      if (candidate === FRONTMATTER_DELIMITER) {
+        const closingStart = search;
+        const closingEnd = nextNewline === -1 ? segmentEnd : nextNewline + 1;
+        return {
+          start: openStart,
+          openEnd,
+          closingStart,
+          closingEnd
+        };
+      }
+      if (nextNewline === -1) {
+        break;
+      }
+      search = nextNewline + 1;
+    }
+    return null;
+  }
+  return null;
+}
+function parseYamlMetadata(source) {
+  const document = parseDocument(source, { prettyErrors: true });
+  if (document.errors.length > 0) {
+    const error = document.errors[0];
+    const location = error.linePos && error.linePos.length > 0 ? error.linePos[0] : null;
+    const position = location ? ` (line ${location.line + 1}, column ${location.col + 1})` : "";
+    throw new DocScribeParseError(`Invalid YAML frontmatter${position}: ${error.message}`, {
+      cause: error
+    });
+  }
+  let raw;
+  try {
+    raw = document.toJS({ mapAsMap: false });
+  } catch (error) {
+    throw new DocScribeParseError("Failed to parse YAML frontmatter", {
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+  if (raw == null) {
+    return {};
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new DocScribeParseError("YAML frontmatter must be a mapping at the top level");
+  }
+  return normalizeMetadata(raw);
+}
+function normalizeMetadata(raw) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(raw)) {
+    normalized[key] = normalizeMetadataValue(value);
+  }
+  const base = {};
+  for (const [key, value] of Object.entries(normalized)) {
+    if (STRING_KEYS.has(key) || key === "tags" || key === "relatedDocs") {
+      continue;
+    }
+    base[key] = value;
+  }
+  const metadata = {
+    ...base,
+    ...normalized.title !== void 0 ? { title: ensureStringValue(normalized.title) } : {},
+    ...normalized.description !== void 0 ? { description: ensureStringValue(normalized.description) } : {},
+    ...normalized.author !== void 0 ? { author: ensureStringValue(normalized.author) } : {},
+    ...normalized.date !== void 0 ? { date: ensureStringValue(normalized.date) } : {},
+    ...normalized.lastUpdated !== void 0 ? { lastUpdated: ensureStringValue(normalized.lastUpdated) } : {},
+    ...normalized.status !== void 0 ? { status: ensureStringValue(normalized.status) } : {},
+    ...normalized.version !== void 0 ? { version: ensureStringValue(normalized.version) } : {},
+    ...normalized.tags !== void 0 ? (() => {
+      const tags = ensureStringArray(normalized.tags);
+      return tags.length > 0 ? { tags } : {};
+    })() : {},
+    ...normalized.relatedDocs !== void 0 ? (() => {
+      const related = ensureStringArray(normalized.relatedDocs);
+      return related.length > 0 ? { relatedDocs: related } : {};
+    })() : {}
+  };
+  return metadata;
+}
+function normalizeMetadataValue(value) {
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => normalizeMetadataValue(item)
+    );
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [key, nested] of Object.entries(value)) {
+      result[key] = normalizeMetadataValue(nested);
+    }
+    return result;
+  }
+  return String(value);
+}
+function ensureStringValue(value) {
+  if (value === null) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => ensureStringArrayItem(item)).join(", ");
+  }
+  return JSON.stringify(value);
+}
+function ensureStringArray(value) {
+  return ensureStringArrayItem(value);
+}
+function ensureStringArrayItem(value) {
+  if (value === null) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return [String(value)];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => ensureStringArrayItem(item));
+  }
+  return [JSON.stringify(value)];
+}
+
+// src/docscribe/headers.ts
+var ATX_PATTERN = /^ {0,3}(#{1,6})(?:[ \t]+|$)(.*)$/;
+var SETEXT_PATTERN = /^ {0,3}(=+|-+)\s*$/;
+function extractHeaders(input, options) {
+  const { content } = normalizeInput(input);
+  const parsed = parseFrontmatter(content);
+  const body = parsed.body;
+  const lineOffset = parsed.bodyStartLine;
+  const slugify = options?.slugify ?? defaultSlugify;
+  const maxDepth = options?.maxDepth ?? 6;
+  const lines = body.split("\n");
+  const headers = [];
+  let inFence = false;
+  let fenceMarker = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trimEnd();
+    const lineNumber = lineOffset + index;
+    const fenceMatch = line.match(/^ {0,3}(```+|~~~+)/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker;
+      } else if (fenceMarker === marker) {
+        inFence = false;
+        fenceMarker = null;
+      }
+      continue;
+    }
+    if (inFence) {
+      continue;
+    }
+    if (/^( {4}|\t)/.test(line)) {
+      continue;
+    }
+    const atxMatch = trimmed.match(ATX_PATTERN);
+    if (atxMatch) {
+      const level = atxMatch[1].length;
+      if (level <= maxDepth) {
+        const rawText = atxMatch[2].replace(/#+\s*$/, "").trim();
+        const text = rawText.length > 0 ? rawText : "";
+        const slug = ensureSlug(slugify, text, lineNumber);
+        headers.push({ level, text, slug, line: lineNumber });
+      }
+      continue;
+    }
+    if (trimmed.length === 0) {
+      continue;
+    }
+    if (index + 1 >= lines.length) {
+      continue;
+    }
+    const nextLine = lines[index + 1];
+    const setextMatch = SETEXT_PATTERN.exec(nextLine.trimEnd());
+    if (setextMatch) {
+      const underline = setextMatch[1];
+      const level = underline.startsWith("=") ? 1 : 2;
+      if (level <= maxDepth) {
+        const text = trimmed.trim();
+        if (text.length > 0 && !/^ {0,3}(```|~~~)/.test(text)) {
+          const slug = ensureSlug(slugify, text, lineNumber);
+          headers.push({ level, text, slug, line: lineNumber });
+        }
+      }
+      index += 1;
+    }
+  }
+  return headers;
+}
+function defaultSlugify(value) {
+  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function ensureSlug(slugify, text, lineNumber) {
+  const candidate = slugify(text);
+  if (candidate && candidate.trim().length > 0) {
+    return candidate;
+  }
+  return `section-${lineNumber}`;
+}
+
+// src/docscribe/format.ts
+var JSON_PATTERN = /^[\s\t]*[[{]/;
+var TOML_ASSIGNMENT = /^[A-Za-z0-9_"'\-.]+\s*=\s*.+$/;
+var TOML_TABLE = /^\s*\[[^\]]+\]\s*$/;
+var YAML_KEY_PATTERN = /^\s*[\w"'-]+\s*:\s*.+$/;
+var MARKDOWN_HEADING = /(\n|^)\s{0,3}#{1,6}\s+/;
+var MARKDOWN_LIST = /(\n|^)\s{0,3}(?:-|\*|\+)\s+/;
+var MARKDOWN_SETEXT = /(\n|^).+\n\s{0,3}(?:=+|-+)\s*(\n|$)/;
+function detectFormat(input) {
+  const { content } = normalizeInput(input);
+  return detectFormatFromContent(content);
+}
+function inspectDocument(input, options) {
+  const { content } = normalizeInput(input);
+  const format = detectFormatFromContent(content);
+  const frontmatter = parseFrontmatter(content);
+  const headers = extractHeaders(content, options);
+  const headerCount = headers.length;
+  const estimatedSections = headerCount > 0 ? headerCount : frontmatter.body.trim().length > 0 ? 1 : 0;
+  const lineCount = content.length === 0 ? 0 : content.split("\n").length;
+  const size = content.length;
+  return {
+    format,
+    hasFrontmatter: frontmatter.metadata !== null,
+    frontmatterRange: frontmatter.range,
+    metadata: frontmatter.metadata,
+    headerCount,
+    estimatedSections,
+    bodyStartLine: frontmatter.bodyStartLine,
+    lineCount,
+    size,
+    headers
+  };
+}
+function detectFormatFromContent(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) {
+    return "plain";
+  }
+  if (looksLikeJson(trimmed)) {
+    return "json";
+  }
+  if (looksLikeToml(trimmed)) {
+    return "toml";
+  }
+  const yamlSeparatorCount = countYamlSeparators(content);
+  if (yamlSeparatorCount >= 1 && isLikelyYamlStream(content)) {
+    return "yaml-stream";
+  }
+  const markdownIndicators = hasMarkdownIndicators(content);
+  if (looksLikeYaml(trimmed) && !markdownIndicators) {
+    return "yaml";
+  }
+  const frontmatter = parseFrontmatter(content);
+  if (frontmatter.metadata !== null) {
+    const body = frontmatter.body.trim();
+    if (markdownIndicators || MARKDOWN_HEADING.test(body) || MARKDOWN_LIST.test(body)) {
+      return "markdown";
+    }
+    if (!body) {
+      return "markdown";
+    }
+  }
+  if (markdownIndicators) {
+    return "markdown";
+  }
+  return "plain";
+}
+function looksLikeJson(trimmed) {
+  if (!JSON_PATTERN.test(trimmed)) {
+    return false;
+  }
+  try {
+    JSON.parse(trimmed);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+function looksLikeToml(content) {
+  const lines = content.split("\n");
+  let tableCount = 0;
+  let assignmentCount = 0;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    if (TOML_TABLE.test(line)) {
+      tableCount += 1;
+      continue;
+    }
+    if (TOML_ASSIGNMENT.test(line)) {
+      assignmentCount += 1;
+    }
+  }
+  return tableCount > 0 || assignmentCount >= 3;
+}
+function looksLikeYaml(trimmed) {
+  if (trimmed.startsWith("%YAML")) {
+    return true;
+  }
+  const lines = trimmed.split("\n");
+  let signal = 0;
+  for (const raw of lines.slice(0, 20)) {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    if (line === "---") {
+      signal += 1;
+      continue;
+    }
+    if (YAML_KEY_PATTERN.test(line) || /^-\s/.test(line)) {
+      signal += 1;
+    }
+  }
+  return signal >= 2;
+}
+function countYamlSeparators(content) {
+  const matches = content.match(/(^|\n)---\s*(\n|$)/g);
+  return matches ? matches.length : 0;
+}
+function isLikelyYamlStream(content) {
+  const lines = content.split("\n");
+  let yamlSignals = 0;
+  let markdownSignals = 0;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line === "" || line === "---") {
+      continue;
+    }
+    if (/^#/.test(line) || /^\s{0,3}(?:-|\*|\+)\s+/.test(line) || /(\[[^\]]+\]\([^)]+\))/.test(line)) {
+      markdownSignals += 1;
+    }
+    if (/:\s/.test(line) || /^-\s/.test(line)) {
+      yamlSignals += 1;
+    }
+  }
+  return yamlSignals >= 2 && markdownSignals === 0;
+}
+function hasMarkdownIndicators(content) {
+  return MARKDOWN_HEADING.test(content) || MARKDOWN_LIST.test(content) || MARKDOWN_SETEXT.test(content) || /(\n|^)\s{0,3}>\s+/.test(content) || /(\[[^\]]+\]\([^)]+\))/.test(content);
+}
+var __internal = {
+  detectFormatFromContent,
+  looksLikeJson,
+  looksLikeToml,
+  looksLikeYaml,
+  isLikelyYamlStream
+};
+
+// src/docscribe/split.ts
+function splitDocuments(input, options) {
+  const { content } = normalizeInput(input);
+  const trimmed = content.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const maxDocuments = options?.maxDocuments ?? Number.POSITIVE_INFINITY;
+  const format = detectFormat(content);
+  let splits;
+  if (format === "yaml-stream") {
+    splits = withIndices(splitYamlStream(content));
+  } else if (format === "markdown") {
+    const markdownSplits = splitMarkdownDocuments(content);
+    splits = markdownSplits.length > 0 ? withIndices(markdownSplits) : [withIndex(buildSingleSplit(content, format, 1), 0)];
+  } else {
+    splits = [withIndex(buildSingleSplit(content, format, 1), 0)];
+  }
+  return applyDocumentLimit(splits, maxDocuments);
+}
+function splitYamlStream(content) {
+  const lines = content.split("\n");
+  const docs = [];
+  let current = { lines: [], startLine: 1 };
+  let delimiterCount = 0;
+  const flush = () => {
+    if (current.lines.join("\n").trim().length === 0) {
+      current = { lines: [], startLine: current.startLine };
+      return;
+    }
+    docs.push({ ...current, lines: [...current.lines] });
+    current = { lines: [], startLine: current.startLine };
+  };
+  for (let index = 0; index < lines.length; index += 1) {
+    const lineNumber = index + 1;
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (trimmed === "---") {
+      delimiterCount += 1;
+      flush();
+      current = { lines: [], startLine: lineNumber + 1 };
+      continue;
+    }
+    if (delimiterCount === 0) {
+      current.startLine = 1;
+    }
+    current.lines.push(line);
+  }
+  flush();
+  if (docs.length === 0) {
+    return [buildRawSplit(content, "yaml", null, 1, content.split("\n").length)];
+  }
+  return docs.map((doc) => {
+    const joined = doc.lines.join("\n");
+    const lineCount = doc.lines.length;
+    return buildRawSplit(
+      joined,
+      "yaml",
+      null,
+      doc.startLine,
+      doc.startLine + Math.max(lineCount - 1, 0)
+    );
+  }).filter((split) => split.content.trim().length > 0);
+}
+function splitMarkdownDocuments(content) {
+  const frontmatter = parseFrontmatter(content);
+  const lines = content.split("\n");
+  const docs = [];
+  const frontmatterLimit = frontmatter.metadata ? Math.max(frontmatter.bodyStartLine - 1, 0) : 0;
+  let current = { lines: [], startLine: 1 };
+  let inFence = false;
+  let fenceMarker = null;
+  const flush = () => {
+    if (current.lines.join("\n").trim().length === 0) {
+      current = { lines: [], startLine: current.startLine };
+      return;
+    }
+    docs.push({ ...current, lines: [...current.lines] });
+    current = { lines: [], startLine: current.startLine };
+  };
+  for (let index = 0; index < lines.length; index += 1) {
+    const lineNumber = index + 1;
+    const line = lines[index];
+    const trimmed = line.trimEnd();
+    const fenceMatch = line.match(/^ {0,3}(```+|~~~+)/);
+    if (fenceMatch) {
+      const marker = fenceMatch[1][0];
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker;
+      } else if (fenceMarker === marker) {
+        inFence = false;
+        fenceMarker = null;
+      }
+    }
+    const isPrimaryFrontmatter = frontmatterLimit > 0 && lineNumber <= frontmatterLimit;
+    if (!inFence && !isPrimaryFrontmatter && trimmed === "---") {
+      const prev = findPrevNonEmpty(lines, index - 1);
+      const next = findNextNonEmpty(lines, index + 1);
+      const prevLooksLikeMetadata = prev ? /:\s*/.test(prev.line) : false;
+      const nextIsHeading = next ? next.line.trim().startsWith("#") : false;
+      if (next && !prevLooksLikeMetadata && nextIsHeading) {
+        flush();
+        current = { lines: [], startLine: next.lineNumber };
+        continue;
+      }
+    }
+    current.lines.push(line);
+  }
+  flush();
+  return docs.map((doc) => {
+    const contentValue = doc.lines.join("\n");
+    const parsed = parseFrontmatter(contentValue);
+    const lineCount = doc.lines.length;
+    return buildRawSplit(
+      contentValue,
+      "markdown",
+      parsed.metadata,
+      doc.startLine,
+      doc.startLine + Math.max(lineCount - 1, 0),
+      parsed.metadata !== null
+    );
+  }).filter((split) => split.content.trim().length > 0);
+}
+function buildSingleSplit(content, format, startLine) {
+  const parsed = parseFrontmatter(content);
+  const lineCount = content.length === 0 ? 0 : content.split("\n").length;
+  return buildRawSplit(
+    content,
+    format,
+    parsed.metadata,
+    startLine,
+    startLine + Math.max(lineCount - 1, 0),
+    parsed.metadata !== null
+  );
+}
+function buildRawSplit(content, format, metadata, startLine, endLine, hasFrontmatter = false) {
+  return {
+    content,
+    format,
+    hasFrontmatter,
+    metadata: metadata ?? null,
+    startLine,
+    endLine
+  };
+}
+function applyDocumentLimit(splits, maxDocuments) {
+  if (maxDocuments <= 0) {
+    return [];
+  }
+  if (splits.length <= maxDocuments) {
+    return splits.map((split, idx) => ({ ...split, index: idx }));
+  }
+  const cutoff = Math.max(maxDocuments - 1, 0);
+  const allowed = splits.slice(0, cutoff);
+  const remaining = splits.slice(cutoff);
+  const merged = mergeSplitGroup(remaining);
+  const combined = cutoff === 0 ? [merged] : [...allowed, merged];
+  return combined.map((split, idx) => ({ ...split, index: idx }));
+}
+function mergeSplitGroup(splits) {
+  const first = splits[0];
+  const last = splits[splits.length - 1];
+  const combinedContent = splits.map((split) => split.content).join("\n---\n");
+  return {
+    content: combinedContent,
+    format: first.format,
+    hasFrontmatter: first.hasFrontmatter,
+    metadata: first.metadata,
+    startLine: first.startLine,
+    endLine: last.endLine,
+    index: 0
+  };
+}
+function withIndices(rawSplits) {
+  return rawSplits.map((split, idx) => withIndex(split, idx));
+}
+function withIndex(split, index) {
+  return { ...split, index };
+}
+function findNextNonEmpty(lines, startIndex) {
+  for (let index = startIndex; index < lines.length; index += 1) {
+    const candidate = lines[index];
+    if (candidate.trim().length === 0) {
+      continue;
+    }
+    return { line: candidate, lineNumber: index + 1 };
+  }
+  return null;
+}
+function findPrevNonEmpty(lines, startIndex) {
+  for (let index = startIndex; index >= 0; index -= 1) {
+    const candidate = lines[index];
+    if (candidate.trim().length === 0) {
+      continue;
+    }
+    return { line: candidate, lineNumber: index + 1 };
+  }
+  return null;
+}
+
+export { DocScribeError, DocScribeParseError, DocScribeUnsupportedFormatError, __internal, detectFormat, extractHeaders, extractMetadata, inspectDocument, normalizeInput, parseFrontmatter, splitDocuments, stripFrontmatter };
+//# sourceMappingURL=chunk-BCO3FUUO.js.map
+//# sourceMappingURL=chunk-BCO3FUUO.js.map