flex-md 4.2.0 → 4.2.2

package/README.md

@@ -564,6 +564,38 @@ if (status === 'validated' || status === 'fixed') {
 2. **Type Enforcement**: Lists and Tables are automatically converted to JSON arrays and objects.
 3. **Single Source of Truth**: Use the same spec to guide the LLM AND parse its response.
 
+## Advanced AI Features (via NX-MD-Parser 1.4.0)
+
+Flex-MD utilizes the full power of `nx-md-parser` v1.4.0, providing enterprise-grade AI transformation capabilities.
+
+### 🤖 Multi-Algorithm Fuzzy Matching
+The engine uses a weighted combination of four powerful algorithms to find the best match for your headings and keys:
+- **Jaro-Winkler**: Character-level similarity (40%)
+- **Jaccard Tokens**: Token-based similarity (30%)
+- **Dice Coefficient**: N-gram similarity (20%)
+- **Levenshtein Ratio**: Edit distance (10%)
+
+### 🧠 Machine Learning (Learn Aliases)
+You can let the system learn from your data to improve matching over time.
+
+```typescript
+import { learnAliasesFromTransformations } from 'flex-md';
+
+const learningResult = learnAliasesFromTransformations([
+  {
+    input: { "Projct Name": "Test" },
+    output: { title: "Test" },
+    schema: yourSchema
+  }
+]);
+// System now knows "Projct Name" is an alias for "title"
+```
+
+### ⚙️ Intelligent Auto-Fixing
+- **Typo Correction**: Automatically fixes property name typos.
+- **Structural Repair**: Restructures flat objects into nested schemas.
+- **Smart Conversion**: Automatically handles `string -> number`, `string -> boolean`, and wrapper types.
+
 ## Spec Memory: Remember & Recall
 
 Flex-MD includes an in-memory storage feature that allows you to "remember" an Output Format Spec and later reuse it by a unique `recallId`. This is especially useful for maintaining state within a single execution environment.

package/dist/extract/extract.js

@@ -3,7 +3,25 @@ import { parseHeadingsAndSections, extractBullets, normalizeName } from "../md/p
  * Extracts sections, lists, and tables from Markdown based on the OFS.
  */
 export function extractFromMarkdown(md, spec) {
-    const parsed = parseHeadingsAndSections(md);
+    // 0. Robustness: check for fenced block that might contain the target content
+    // Highly relevant for LLM responses where the model occasionally wraps everything in a container
+    // even if not strictly asked, or if the user provided unframed content but we have L2+ expectations elsewhere.
+    const rxFence = /```(?:markdown|flexmd)?\s*\n([\s\S]*?)\n```/gi;
+    const matches = Array.from(md.matchAll(rxFence));
+    let workingContent = md;
+    if (matches.length === 1) {
+        const content = matches[0][1];
+        // If the content inside the fence has more required sections than outside, use it
+        const parsedOutside = parseHeadingsAndSections(md);
+        const parsedInside = parseHeadingsAndSections(content);
+        const specNorms = new Set(spec.sections.map(s => normalizeName(s.name)));
+        const countOutside = parsedOutside.filter(p => specNorms.has(normalizeName(p.heading.name))).length;
+        const countInside = parsedInside.filter(p => specNorms.has(normalizeName(p.heading.name))).length;
+        if (countInside >= countOutside && countInside > 0) {
+            workingContent = content;
+        }
+    }
+    const parsed = parseHeadingsAndSections(workingContent);
     const sectionsByName = {};
     const tables = [];
     const specMap = new Map(spec.sections.map(s => [normalizeName(s.name), s]));

package/dist/md/parse.js

@@ -29,8 +29,10 @@ export function extractFencedBlocks(text) {
     return blocks;
 }
 export function parseHeadingsAndSections(md) {
-    // Standard headings #... and alternative ===key
-    const rx = /^((?:#{1,6})\s+(.+?)\s*|===(.+?)\s*)$/gm;
+    // Standard headings #... and alternative ===key.
+    // Use [ \t]* instead of \s for the trailing space to avoid matching newlines incorrectly with certain configurations.
+    // Also include \r? to handle CRLF if needed, although m and g should handle ^\$ correctly.
+    const rx = /^((?:#{1,6})[ \t]+(.+?)[ \t]*|===(.+?)[ \t]*)$/gm;
     const headings = [];
     let m;
     while ((m = rx.exec(md)) !== null) {
@@ -42,7 +44,8 @@ export function parseHeadingsAndSections(md) {
             name = (m[3] ?? "").trim();
         }
         else {
-            const hashes = (full.match(/^#+/) ?? [""])[0];
+            const hashesMatch = full.match(/^#+/);
+            const hashes = hashesMatch ? hashesMatch[0] : "";
             level = hashes.length;
             name = (m[2] ?? "").trim();
         }

package/dist/ofs/parser.js

@@ -1,3 +1,4 @@
+import { normalizeName } from "../md/parse.js";
 /**
  * Validate a format specification.
  * Returns detailed validation results.
@@ -138,6 +139,18 @@ export function parseOutputFormatSpec(md, opts = {}) {
             }
             continue;
         }
+        // heading items (e.g. ### Short Answer)
+        const headingMatch = line.match(/^#{1,6}\s+(.+)$/);
+        if (headingMatch) {
+            const name = headingMatch[1].trim();
+            // Don't re-parse "Output format" itself if it somehow gets in here
+            if (normalizeName(name) !== "output format") {
+                const s = { name, kind: "text" };
+                sections.push(s);
+                currentSection = s;
+            }
+            continue;
+        }
         // If not a bullet and we have a current section, it's an instruction
         if (currentSection && line.length > 0) {
             // Support "Columns: A, B, C" in instructions for tables

package/dist/pipeline/kind.js

@@ -2,8 +2,11 @@ import { isIssuesEnvelopeCheck } from "../md/parse.js";
 export function detectResponseKind(text, spec) {
     const issuesResult = isIssuesEnvelopeCheck(text);
     const hasIssues = issuesResult.isIssuesEnvelope;
+    // Use more robust detection: check for both #+ Name and ===Name
     const hasSections = spec.sections.some(s => {
-        const rx = new RegExp(`^#+\\s+${s.name}`, "im");
+        // Escape special chars in name but match case-insensitively and with flexible whitespace
+        const escapedName = s.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const rx = new RegExp(`^((?:#{1,6}\\s+${escapedName})|(?:===${escapedName}))\\s*$`, "im");
         return rx.test(text);
     });
     const isRawJson = /^\s*(\{|\[)/.test(text.trim()) && /\s*(\}|\])$/.test(text.trim());

package/dist/validate/validate.js

@@ -248,13 +248,21 @@ export function validateMarkdownAgainstOfs(input, spec, level, policyOverride) {
             }
         }
     }
+    // Compute detectedKind more robustly: if we found more than zero sections, it's at least sectioned
+    let detectedKind = "markdown";
+    if (level >= 2) {
+        detectedKind = fencesAll.length > 0 ? "fenced" : (parsed.length > 0 ? "sectioned" : "markdown");
+    }
+    else {
+        detectedKind = parsed.length > 0 ? "sectioned" : "markdown";
+    }
     const ok = !issues.some(i => i.severity === "error");
     return {
         ok,
         level,
         issues,
         stats: {
-            detectedKind: level >= 2 ? (fencesAll.length ? "fenced" : "markdown") : (parsed.length ? "sectioned" : "markdown"),
+            detectedKind,
             sectionCount: occurrences.size,
             missingRequired,
             duplicates,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flex-md",
-  "version": "4.2.0",
+  "version": "4.2.2",
   "description": "Parse and stringify FlexMD: semi-structured Markdown with three powerful layers - Frames, Output Format Spec (OFS), and Detection/Extraction.",
   "license": "MIT",
   "author": "",