flex-md 4.2.7 → 4.3.0

package/dist/md/normalize.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Centralized normalization for Markdown input.
+ * Handles common LLM output artifacts like literal \n.
+ */
+export declare function normalizeMarkdownInput(md: string): string;

package/dist/md/normalize.js

@@ -0,0 +1,10 @@
+/**
+ * Centralized normalization for Markdown input.
+ * Handles common LLM output artifacts like literal \n.
+ */
+export function normalizeMarkdownInput(md) {
+    if (!md)
+        return "";
+    // Handle literal \n common in LLM outputs delivered via JSON
+    return md.replace(/\\n/g, "\n");
+}

package/dist/md/parse.js

@@ -1,4 +1,5 @@
 import { toCamelCase } from "nx-helpers";
+import { normalizeMarkdownInput } from "./normalize.js";
 export function normalizeName(s) {
     return s.trim().replace(/\s+/g, " ").toLowerCase();
 }
@@ -157,12 +158,33 @@ export function isIssuesEnvelopeCheck(md) {
 }
 export function markdownToJson(md) {
     // Robustly handle both actual newlines and literal \n (common in LLM JSON outputs)
-    const normalizedMd = (md || "").replace(/\\n/g, "\n");
-    const sections = parseHeadingsAndSections(normalizedMd);
+    const normalizedMd = 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 = toCamelCase(sec.heading.name);
-        result[key] = sec.body.trim();
+        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;
 }

package/dist/ofs/adapter.d.ts

@@ -6,5 +6,6 @@ import { type OutputFormatSpec } from "../types.js";
 export declare function ofsToSchema(spec: OutputFormatSpec): SchemaType;
 /**
  * Transforms markdown text using a Flex-MD OutputFormatSpec or a recallId.
+ * If no spec is provided, it attempts to infer it from the markdown (autospecs).
  */
-export declare function transformWithOfs<T = any>(md: string, specOrRecallId: OutputFormatSpec | string): TransformResult<T>;
+export declare function transformWithOfs<T = any>(md: string, specOrRecallId?: OutputFormatSpec | string): TransformResult<T>;

package/dist/ofs/adapter.js

@@ -1,6 +1,7 @@
 import { JSONTransformer, Schema } from "nx-md-parser";
 import { recall } from "./memory.js";
-import { parseHeadingsAndSections, extractBullets, parseMarkdownTable, normalizeName } from "../md/parse.js";
+import { parseHeadingsAndSections, extractBullets, parseMarkdownTable, normalizeName, markdownToJson } from "../md/parse.js";
+import { normalizeMarkdownInput } from "../md/normalize.js";
 /**
  * Converts a Flex-MD OutputFormatSpec to an nx-md-parser Schema.
  */
@@ -47,25 +48,39 @@ export function ofsToSchema(spec) {
 }
 /**
  * Transforms markdown text using a Flex-MD OutputFormatSpec or a recallId.
+ * If no spec is provided, it attempts to infer it from the markdown (autospecs).
  */
 export function transformWithOfs(md, specOrRecallId) {
+    // 0. Normalize input (handle literal \n common in LLM outputs)
+    const normalizedMd = normalizeMarkdownInput(md);
+    if (!specOrRecallId) {
+        // AUTOSPECS: If no spec is provided, use internal logic ONLY.
+        // This avoids complex schema generation and keeps it robust for unknown structures.
+        const result = markdownToJson(normalizedMd);
+        return {
+            status: "validated",
+            result: result,
+            errors: []
+        };
+    }
     let spec;
     if (typeof specOrRecallId === "string") {
-        spec = recall(specOrRecallId);
-        if (!spec) {
+        const recalled = recall(specOrRecallId);
+        if (!recalled) {
             return {
                 status: "failed",
                 result: null,
                 errors: [`Recall ID "${specOrRecallId}" not found in memory.`]
             };
         }
+        spec = recalled;
     }
     else {
         spec = specOrRecallId;
     }
     // 1. Parse sections using Flex-MD parser
     const bulletNames = spec.sections.map(s => s.name);
-    const parsedSections = parseHeadingsAndSections(md, { bulletNames });
+    const parsedSections = parseHeadingsAndSections(normalizedMd, { bulletNames });
     const parsedObj = {};
     // 2. Map sections to OFS and apply complex parsing (tables/lists)
     for (const sectionSpec of spec.sections) {

package/dist/ofs/infer.d.ts

@@ -0,0 +1,5 @@
+import { OutputFormatSpec } from "../types.js";
+/**
+ * Infers an OutputFormatSpec from a Markdown string.
+ */
+export declare function inferOfsFromMarkdown(md: string): OutputFormatSpec;

package/dist/ofs/infer.js

@@ -0,0 +1,60 @@
+import { parseHeadingsAndSections, extractBullets } from "../md/parse.js";
+/**
+ * Infers an OutputFormatSpec from a Markdown string.
+ */
+export function inferOfsFromMarkdown(md) {
+    // Collect all bullet names that look like headers ("- Name")
+    const lines = md.split("\n");
+    const bulletNames = [];
+    for (const line of lines) {
+        // Match "- Name" or "- Name\n" or "- Name " but NOT "- Name: more text"
+        const m = line.match(/^[-*+]\s+([^—:\n]+)$/);
+        if (m) {
+            bulletNames.push(m[1].trim());
+        }
+    }
+    const sections = parseHeadingsAndSections(md, { bulletNames });
+    const specSections = [];
+    for (const sec of sections) {
+        const name = sec.heading.name;
+        const body = sec.body.trim();
+        // 1. Detect list
+        const bullets = extractBullets(body);
+        if (bullets.length > 0) {
+            specSections.push({
+                name,
+                kind: "list",
+                required: true
+            });
+            continue;
+        }
+        // 2. Detect table (basic check)
+        const lines = body.split("\n").map(l => l.trim()).filter(Boolean);
+        if (lines.length >= 2 && lines[0].startsWith("|") && /^[|\s-:]+$/.test(lines[1])) {
+            // Extract columns
+            const cols = lines[0].split("|").map(c => c.trim()).filter(Boolean);
+            specSections.push({
+                name,
+                kind: "table",
+                columns: cols,
+                required: true
+            });
+            continue;
+        }
+        // Default to text
+        specSections.push({
+            name,
+            kind: "text",
+            required: true
+        });
+    }
+    return {
+        descriptorType: "output_format_spec",
+        format: "markdown",
+        sectionOrderMatters: false,
+        sections: specSections,
+        tablesOptional: true,
+        tables: [],
+        emptySectionValue: "None"
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flex-md",
-  "version": "4.2.7",
+  "version": "4.3.0",
   "description": "Parse and stringify FlexMD: semi-structured Markdown with three powerful layers - Frames, Output Format Spec (OFS), and Detection/Extraction.",
   "license": "MIT",
   "author": "",
@@ -52,4 +52,4 @@
     "nx-helpers": "^1.5.0",
     "nx-md-parser": "^2.0.2"
   }
-}
+}