flex-md 4.7.1 → 4.7.3

package/dist-cjs/flex-md-loader.cjs

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Flex-MD Loader - ES Module Compatible Dynamic Import
+ *
+ * This module provides ES module compatible dynamic loading of the flex-md library,
+ * handling the case where dependencies might use require() in ES module environments.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJsonFromFlexMd = extractJsonFromFlexMd;
+exports.extractWithOfs = extractWithOfs;
+exports.loadFlexMd = loadFlexMd;
+/**
+ * Dynamically loads the flex-md library with ES module compatibility.
+ * Handles both ES module and CommonJS loading patterns.
+ */
+async function loadFlexMd() {
+    try {
+        // First, try direct ES module import (preferred for modern environments)
+        const flexMdModule = await Promise.resolve().then(() => require('flex-md'));
+        return flexMdModule;
+    }
+    catch (esError) {
+        try {
+            // Fallback: Use Node.js createRequire for CommonJS compatibility
+            // This handles cases where flex-md or its dependencies use require()
+            const { createRequire } = await Promise.resolve().then(() => require('module'));
+            const require = createRequire(import.meta.url);
+            const flexMdModule = require('flex-md');
+            return flexMdModule;
+        }
+        catch (cjsError) {
+            // If both fail, try the dynamic Function approach as last resort
+            try {
+                const importFunc = new Function('specifier', 'return import(specifier)');
+                const flexMdModule = await importFunc('flex-md');
+                return flexMdModule;
+            }
+            catch (dynamicError) {
+                throw new Error(`flex-md import failed: ES module error: ${esError instanceof Error ? esError.message : String(esError)}, ` +
+                    `CommonJS fallback error: ${cjsError instanceof Error ? cjsError.message : String(cjsError)}, ` +
+                    `Dynamic import error: ${dynamicError instanceof Error ? dynamicError.message : String(dynamicError)}`);
+            }
+        }
+    }
+}
+/**
+ * Extracts structured JSON from markdown content using flex-md.
+ *
+ * @param content - The markdown content to parse
+ * @param spec - Optional Output Format Specification
+ * @param options - Extraction options
+ * @returns Promise resolving to extraction result
+ */
+async function extractJsonFromFlexMd(content, spec, options = {}) {
+    try {
+        // Load flex-md library with compatibility handling
+        const flexMd = await loadFlexMd();
+        // Use the markdownToJson function for basic structured extraction
+        // This handles markdown with sections like # Short answer, # Full answer, etc.
+        const json = flexMd.markdownToJson(content);
+        return {
+            json,
+            success: true
+        };
+    }
+    catch (error) {
+        console.warn('Flex-md extraction failed - flex-md library compatibility issue');
+        console.warn('Error:', error instanceof Error ? error.message : String(error));
+        console.warn('Issue: flex-md uses require() in ES module context - needs fixing in flex-md-loader.ts');
+        return {
+            json: { rawText: content },
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown extraction error'
+        };
+    }
+}
+/**
+ * Alternative extraction using transformWithOfs if a spec is provided.
+ * This provides more structured extraction when an Output Format Spec is available.
+ */
+async function extractWithOfs(content, spec, options = {}) {
+    try {
+        const flexMd = await loadFlexMd();
+        // If spec is provided, use the more advanced transformWithOfs
+        if (spec && flexMd.transformWithOfs) {
+            const result = flexMd.transformWithOfs(content, spec);
+            return {
+                json: result,
+                success: true
+            };
+        }
+        else {
+            // Fallback to basic markdownToJson
+            return extractJsonFromFlexMd(content, spec, options);
+        }
+    }
+    catch (error) {
+        console.warn('Flex-md OFS extraction failed:', error instanceof Error ? error.message : String(error));
+        // Fallback to basic extraction
+        return extractJsonFromFlexMd(content, spec, options);
+    }
+}

package/dist-cjs/index.cjs

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonToMarkdown = exports.Schema = exports.MarkdownParser = exports.JSONTransformer = exports.enforceFlexMd = exports.repairToMarkdownLevel = exports.detectResponseKind = exports.buildIssuesEnvelopeAuto = exports.buildIssuesEnvelope = exports.parseIssuesEnvelope = exports.processResponseMarkdown = exports.extractFromMarkdown = exports.checkConnection = exports.hasFlexMdContract = exports.checkCompliance = exports.validateMarkdownAgainstOfs = exports.enrichInstructionsWithFlexMd = exports.enrichInstructions = exports.buildMarkdownGuidance = exports.stringifyOutputFormatSpec = exports.recall = exports.remember = exports.transformWithOfs = exports.ofsToSchema = exports.validateFormat = exports.parseFormatSpecs = exports.parseInputFormatSpec = exports.parseOutputFormatSpec = exports.buildOutline = exports.logger = void 0;
+// Core SFMD Types
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./strictness/types.cjs"), exports);
+// Logging
+var logger_js_1 = require("./logger.cjs");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_js_1.logger; } });
+// Shared MD Parsing
+__exportStar(require("./md/parse.cjs"), exports);
+var outline_js_1 = require("./md/outline.cjs");
+Object.defineProperty(exports, "buildOutline", { enumerable: true, get: function () { return outline_js_1.buildOutline; } });
+// Output Format Spec (OFS)
+var parser_js_1 = require("./ofs/parser.cjs");
+Object.defineProperty(exports, "parseOutputFormatSpec", { enumerable: true, get: function () { return parser_js_1.parseOutputFormatSpec; } });
+Object.defineProperty(exports, "parseInputFormatSpec", { enumerable: true, get: function () { return parser_js_1.parseInputFormatSpec; } });
+Object.defineProperty(exports, "parseFormatSpecs", { enumerable: true, get: function () { return parser_js_1.parseFormatSpecs; } });
+Object.defineProperty(exports, "validateFormat", { enumerable: true, get: function () { return parser_js_1.validateFormat; } });
+var adapter_js_1 = require("./ofs/adapter.cjs");
+Object.defineProperty(exports, "ofsToSchema", { enumerable: true, get: function () { return adapter_js_1.ofsToSchema; } });
+Object.defineProperty(exports, "transformWithOfs", { enumerable: true, get: function () { return adapter_js_1.transformWithOfs; } });
+var memory_js_1 = require("./ofs/memory.cjs");
+Object.defineProperty(exports, "remember", { enumerable: true, get: function () { return memory_js_1.remember; } });
+Object.defineProperty(exports, "recall", { enumerable: true, get: function () { return memory_js_1.recall; } });
+var stringify_js_1 = require("./ofs/stringify.cjs");
+Object.defineProperty(exports, "stringifyOutputFormatSpec", { enumerable: true, get: function () { return stringify_js_1.stringifyOutputFormatSpec; } });
+var enricher_js_1 = require("./ofs/enricher.cjs");
+Object.defineProperty(exports, "buildMarkdownGuidance", { enumerable: true, get: function () { return enricher_js_1.buildMarkdownGuidance; } });
+Object.defineProperty(exports, "enrichInstructions", { enumerable: true, get: function () { return enricher_js_1.enrichInstructions; } });
+Object.defineProperty(exports, "enrichInstructionsWithFlexMd", { enumerable: true, get: function () { return enricher_js_1.enrichInstructionsWithFlexMd; } });
+// Validation & Extraction
+var validate_js_1 = require("./validate/validate.cjs");
+Object.defineProperty(exports, "validateMarkdownAgainstOfs", { enumerable: true, get: function () { return validate_js_1.validateMarkdownAgainstOfs; } });
+var compliance_js_1 = require("./validate/compliance.cjs");
+Object.defineProperty(exports, "checkCompliance", { enumerable: true, get: function () { return compliance_js_1.checkCompliance; } });
+Object.defineProperty(exports, "hasFlexMdContract", { enumerable: true, get: function () { return compliance_js_1.hasFlexMdContract; } });
+var connection_js_1 = require("./validate/connection.cjs");
+Object.defineProperty(exports, "checkConnection", { enumerable: true, get: function () { return connection_js_1.checkConnection; } });
+var extract_js_1 = require("./extract/extract.cjs");
+Object.defineProperty(exports, "extractFromMarkdown", { enumerable: true, get: function () { return extract_js_1.extractFromMarkdown; } });
+// Processor & Fallback
+var processor_js_1 = require("./strictness/processor.cjs");
+Object.defineProperty(exports, "processResponseMarkdown", { enumerable: true, get: function () { return processor_js_1.processResponseMarkdown; } });
+var issuesEnvelope_js_1 = require("./ofs/issuesEnvelope.cjs");
+Object.defineProperty(exports, "parseIssuesEnvelope", { enumerable: true, get: function () { return issuesEnvelope_js_1.parseIssuesEnvelope; } });
+Object.defineProperty(exports, "buildIssuesEnvelope", { enumerable: true, get: function () { return issuesEnvelope_js_1.buildIssuesEnvelope; } });
+Object.defineProperty(exports, "buildIssuesEnvelopeAuto", { enumerable: true, get: function () { return issuesEnvelope_js_1.buildIssuesEnvelopeAuto; } });
+// Pipeline
+var kind_js_1 = require("./pipeline/kind.cjs");
+Object.defineProperty(exports, "detectResponseKind", { enumerable: true, get: function () { return kind_js_1.detectResponseKind; } });
+var repair_js_1 = require("./pipeline/repair.cjs");
+Object.defineProperty(exports, "repairToMarkdownLevel", { enumerable: true, get: function () { return repair_js_1.repairToMarkdownLevel; } });
+var enforce_js_1 = require("./pipeline/enforce.cjs");
+Object.defineProperty(exports, "enforceFlexMd", { enumerable: true, get: function () { return enforce_js_1.enforceFlexMd; } });
+// JSON Detection
+__exportStar(require("./detect/json/index.cjs"), exports);
+// Token Estimation
+__exportStar(require("./tokens/index.cjs"), exports);
+// NX-MD-Parser Integration (Structured MD -> JSON)
+var nx_md_parser_1 = require("nx-md-parser");
+Object.defineProperty(exports, "JSONTransformer", { enumerable: true, get: function () { return nx_md_parser_1.JSONTransformer; } });
+Object.defineProperty(exports, "MarkdownParser", { enumerable: true, get: function () { return nx_md_parser_1.MarkdownParser; } });
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return nx_md_parser_1.Schema; } });
+Object.defineProperty(exports, "jsonToMarkdown", { enumerable: true, get: function () { return nx_md_parser_1.jsonToMarkdown; } });

package/dist-cjs/logger.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.threshold = exports.logger = void 0;
+const micro_logs_1 = require("micro-logs");
+// Get DEBUG_LEVEL from environment, default to 'info'
+const debugLevel = process.env.DEBUG_LEVEL || 'info';
+// Map string levels to micro-logs levels
+const levelMapping = {
+    'verbose': 'verbose',
+    'debug': 'debug',
+    'info': 'info',
+    'warn': 'warn',
+    'error': 'error'
+};
+// Default to 'info' if invalid level provided
+const threshold = levelMapping[debugLevel.toLowerCase()] || 'info';
+exports.threshold = threshold;
+exports.logger = new micro_logs_1.Logger({
+    packageName: 'flex-md',
+    envPrefix: 'FLEX_MD',
+    debugNamespace: 'flex-md:*'
+});

package/dist-cjs/md/match.cjs

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSections = matchSections;
+/**
+ * Matches sections from the outline against required section names.
+ * Supports merging multiple nodes of the same name and selecting highest-level matches.
+ */
+function matchSections(outline, sectionNames, strategy = "merge") {
+    const normalizedTargets = new Map(sectionNames.map(n => [norm(n), n]));
+    const found = new Map();
+    walk(outline.nodes, (node) => {
+        const k = norm(node.title);
+        if (normalizedTargets.has(k)) {
+            if (!found.has(k))
+                found.set(k, []);
+            found.get(k).push(node);
+        }
+    });
+    const res = new Map();
+    for (const [nk, originalName] of normalizedTargets.entries()) {
+        const nodes = found.get(nk) ?? [];
+        if (!nodes.length)
+            continue;
+        // choose highest-level (smallest level number)
+        const minLevel = Math.min(...nodes.map(n => n.level));
+        const top = nodes.filter(n => n.level === minLevel);
+        let chosen;
+        if (strategy === "first") {
+            chosen = [top[0]];
+        }
+        else {
+            chosen = top; // merge same-level matches
+        }
+        const merged = chosen.map(n => n.content_md).join("\n").trimEnd() + "\n";
+        res.set(originalName, { name: originalName, nodes, chosen, mergedContent: merged });
+    }
+    return res;
+}
+function walk(nodes, fn) {
+    for (const n of nodes) {
+        fn(n);
+        walk(n.children, fn);
+    }
+}
+function norm(s) {
+    return s.trim().replace(/[:\-–—]\s*$/, "").trim().toLowerCase();
+}

package/dist-cjs/md/normalize.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMarkdownInput = normalizeMarkdownInput;
+/**
+ * Centralized normalization for Markdown input.
+ * Handles common LLM output artifacts like literal \n.
+ */
+function normalizeMarkdownInput(md) {
+    if (!md)
+        return "";
+    // Handle literal \n common in LLM outputs delivered via JSON
+    return md.replace(/\\n/g, "\n");
+}

package/dist-cjs/md/outline.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOutline = buildOutline;
+exports.slugify = slugify;
+const parse_js_1 = require("./parse.cjs");
+/**
+ * Builds a nested tree of headings (outline) from Markdown text.
+ */
+function buildOutline(md) {
+    const sections = (0, parse_js_1.parseHeadingsAndSections)(md);
+    const roots = [];
+    const stack = [];
+    for (const s of sections) {
+        const h = s.heading;
+        const node = {
+            title: h.name,
+            level: h.level,
+            key: h.norm,
+            content_md: s.body,
+            children: []
+        };
+        // Pop from stack until we find a parent (level < node.level)
+        while (stack.length > 0 && stack[stack.length - 1].level >= node.level) {
+            stack.pop();
+        }
+        if (stack.length === 0) {
+            roots.push(node);
+        }
+        else {
+            stack[stack.length - 1].children.push(node);
+        }
+        stack.push(node);
+    }
+    return {
+        type: "md_outline",
+        nodes: roots
+    };
+}
+/**
+ * Slugifies a string into an internal key.
+ */
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}

package/dist-cjs/md/parse.cjs

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeName = normalizeName;
+exports.extractFencedBlocks = extractFencedBlocks;
+exports.parseHeadingsAndSections = parseHeadingsAndSections;
+exports.extractBullets = extractBullets;
+exports.parseMarkdownTable = parseMarkdownTable;
+exports.isIssuesEnvelopeCheck = isIssuesEnvelopeCheck;
+exports.markdownToJson = markdownToJson;
+const nx_helpers_1 = require("nx-helpers");
+const normalize_js_1 = require("./normalize.cjs");
+function normalizeName(s) {
+    return s.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function extractFencedBlocks(text) {
+    const rx = /```(\w+)?\s*\n([\s\S]*?)\n```/g;
+    const blocks = [];
+    let m;
+    while ((m = rx.exec(text)) !== null) {
+        const full = m[0];
+        const lang = String(m[1] ?? "").trim().toLowerCase();
+        const content = m[2] ?? "";
+        const start = m.index;
+        const end = start + full.length;
+        // compute content start/end (best-effort)
+        const headerLen = full.indexOf("\n") + 1; // after first newline
+        const contentEnd = end - 3; // "```" at end
+        const contentStart = start + headerLen;
+        blocks.push({
+            lang,
+            start,
+            end,
+            contentStart,
+            contentEnd,
+            content,
+            full,
+        });
+    }
+    return blocks;
+}
+function parseHeadingsAndSections(md, options = {}) {
+    // Standard headings #... and alternative ===key.
+    // Also optionally allow "- Section" if specified in bulletNames.
+    const rx = /^((?:#{1,6})[ \t]+(.+?)[ \t]*|===(.+?)[ \t]*|([-*+])[ \t]+(.+?)[ \t]*)$/gm;
+    const headings = [];
+    const bulletNamesNormal = new Set((options.bulletNames || []).map(normalizeName));
+    let m;
+    while ((m = rx.exec(md)) !== null) {
+        const full = m[1] ?? "";
+        let level;
+        let name;
+        if (full.startsWith("===")) {
+            level = 1; // Treat ===key as a top-level heading
+            name = (m[3] ?? "").trim();
+        }
+        else if (m[4]) {
+            // It's a bullet (- / * / +)
+            const bulletChar = m[4];
+            const bulletText = (m[5] ?? "").trim();
+            const norm = normalizeName(bulletText);
+            if (bulletNamesNormal.has(norm)) {
+                level = 1;
+                name = bulletText;
+            }
+            else {
+                // Not a recognized section header bullet, ignore it
+                continue;
+            }
+        }
+        else {
+            const hashesMatch = full.match(/^#+/);
+            const hashes = hashesMatch ? hashesMatch[0] : "";
+            level = hashes.length;
+            name = (m[2] ?? "").trim();
+        }
+        const raw = m[0] ?? "";
+        const start = m.index;
+        const end = start + raw.length;
+        headings.push({
+            level,
+            raw,
+            name,
+            norm: normalizeName(name),
+            start,
+            end,
+        });
+    }
+    // compute section bodies
+    const sections = [];
+    for (let i = 0; i < headings.length; i++) {
+        const h = headings[i];
+        const bodyStart = nextLineIndex(md, h.end);
+        let bodyEnd = md.length;
+        for (let j = i + 1; j < headings.length; j++) {
+            const nxt = headings[j];
+            bodyEnd = nxt.start;
+            break;
+        }
+        sections.push({
+            heading: h,
+            bodyStart,
+            bodyEnd,
+            body: md.slice(bodyStart, bodyEnd).trimEnd(),
+        });
+    }
+    return sections;
+}
+function nextLineIndex(text, idx) {
+    if (idx >= text.length)
+        return text.length;
+    if (text[idx] === "\n")
+        return idx + 1;
+    const n = text.indexOf("\n", idx);
+    return n === -1 ? text.length : n + 1;
+}
+function extractBullets(body) {
+    const lines = body.split(/\r?\n/);
+    const out = [];
+    for (const line of lines) {
+        const m = line.match(/^\s*[-*•]\s+(.*)\s*$/) || line.match(/^\s*\d+\.\s+(.*)\s*$/);
+        if (m)
+            out.push(m[1].trim());
+    }
+    return out;
+}
+function parseMarkdownTable(body, columns) {
+    const lines = body.split(/\r?\n/).map(l => l.trim()).filter(l => l.startsWith("|"));
+    if (lines.length < 2)
+        return [];
+    // Identification of header vs separator
+    const headerLine = lines[0];
+    const separatorLine = lines[1];
+    // Check if second line is a separator (e.g. |---|---|)
+    const isSeparator = separatorLine && /^[|\s-:]+$/.test(separatorLine);
+    const dataStartIndex = isSeparator ? 2 : 1;
+    const dataLines = lines.slice(dataStartIndex);
+    const results = [];
+    for (const line of dataLines) {
+        const cells = line.split("|").map(c => c.trim()).filter((_, i, arr) => i > 0 && i < arr.length - 1);
+        const row = {};
+        // Match cells to provided columns by index
+        for (let i = 0; i < columns.length; i++) {
+            row[columns[i]] = cells[i] || "";
+        }
+        results.push(row);
+    }
+    return results;
+}
+function isIssuesEnvelopeCheck(md) {
+    const parsed = parseHeadingsAndSections(md);
+    const want = ["status", "issues", "expected", "found", "how to fix"].map(normalizeName);
+    const got = new Set(parsed.map(s => s.heading.norm));
+    const ok = want.every(w => got.has(w));
+    const sections = {};
+    if (ok) {
+        for (const sec of parsed) {
+            if (want.includes(sec.heading.norm)) {
+                sections[sec.heading.norm] = {
+                    heading: sec.heading.name,
+                    body: sec.body.trim(),
+                    bullets: extractBullets(sec.body),
+                };
+            }
+        }
+    }
+    return { isIssuesEnvelope: ok, sections };
+}
+function markdownToJson(md) {
+    // Robustly handle both actual newlines and literal \n (common in LLM JSON outputs)
+    const normalizedMd = (0, normalize_js_1.normalizeMarkdownInput)(md);
+    // Collect all bullet names that look like headers ("- Name")
+    // We look for patterns like "- Name\n" at the start of lines, ensuring it's not a sub-bullet.
+    const bulletNames = [];
+    const bulletLinesRx = /^[-*+]\s+([^—:\n\r]{2,50})$/gm;
+    let m;
+    while ((m = bulletLinesRx.exec(normalizedMd)) !== null) {
+        bulletNames.push(m[1].trim());
+    }
+    // Use Flex-MD's native parser (supports === headings and avoids colon-as-object bug)
+    const sections = parseHeadingsAndSections(normalizedMd, { bulletNames });
+    const result = {};
+    for (const sec of sections) {
+        const key = (0, nx_helpers_1.toCamelCase)(sec.heading.name);
+        const body = sec.body.trim();
+        // 1. Try to detect list
+        const bullets = extractBullets(body);
+        if (bullets.length > 0) {
+            result[key] = bullets;
+            continue;
+        }
+        // 2. Try to detect table (basic check)
+        const lines = body.split("\n").map(l => l.trim()).filter(l => l);
+        if (lines.length >= 2 && lines[0].startsWith("|") && /^[|\s-:]+$/.test(lines[1])) {
+            // It looks like a table - we could use nx-md-parser's table logic here safely
+        }
+        result[key] = body;
+    }
+    return result;
+}