flex-md 3.5.0 → 4.1.0

package/dist/detection/detector.js

@@ -1,104 +0,0 @@
-/**
- * Detect FlexMD and other structured objects in arbitrary text.
- * Returns all detected objects with confidence scores and byte ranges.
- */
-export function detectObjects(text) {
-    const detected = [];
-    // Tier A: Detect ```flexmd fenced blocks (highest confidence)
-    detected.push(...detectFlexMdFences(text));
-    // Tier B: Detect ```json blocks with FlexDocument shape
-    detected.push(...detectFlexDocJsonFences(text));
-    // Tier C: Detect raw FlexMD markers (best effort)
-    detected.push(...detectRawFlexMd(text));
-    // Sort by start position
-    detected.sort((a, b) => a.start - b.start);
-    return detected;
-}
-/**
- * Tier A: Detect ```flexmd fenced blocks.
- */
-function detectFlexMdFences(text) {
-    const detected = [];
-    const regex = /```flexmd\n([\s\S]*?)```/g;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        detected.push({
-            kind: "flexmd_fence",
-            confidence: 1.0,
-            start: match.index,
-            end: match.index + match[0].length,
-            raw: match[0],
-            inner: match[1]
-        });
-    }
-    return detected;
-}
-/**
- * Tier B: Detect ```json blocks that match FlexDocument shape.
- */
-function detectFlexDocJsonFences(text) {
-    const detected = [];
-    const regex = /```json\n([\s\S]*?)```/g;
-    let match;
-    while ((match = regex.exec(text)) !== null) {
-        const inner = match[1];
-        // Try to parse as JSON
-        try {
-            const parsed = JSON.parse(inner);
-            // Check if it has the FlexDocument shape (has "frames" array)
-            if (parsed && typeof parsed === "object" && Array.isArray(parsed.frames)) {
-                detected.push({
-                    kind: "flexdoc_json_fence",
-                    confidence: 0.9,
-                    start: match.index,
-                    end: match.index + match[0].length,
-                    raw: match[0],
-                    inner
-                });
-            }
-        }
-        catch {
-            // Not valid JSON, skip
-        }
-    }
-    return detected;
-}
-/**
- * Tier C: Detect raw FlexMD markers (best effort).
- * Looks for at least 2 strong markers within first 500 chars:
- * - [[...]]
- * - @key:
- * - @payload:name:
- */
-function detectRawFlexMd(text) {
-    const detected = [];
-    // Look for frame markers
-    const frameRegex = /\[\[([^\]]+)\]\]/g;
-    const metaRegex = /@[a-zA-Z_][a-zA-Z0-9_]*:/g;
-    const payloadRegex = /@payload:[a-zA-Z_][a-zA-Z0-9_]*:/g;
-    let match;
-    const markers = [];
-    // Collect all marker positions
-    while ((match = frameRegex.exec(text)) !== null) {
-        markers.push(match.index);
-    }
-    while ((match = metaRegex.exec(text)) !== null) {
-        markers.push(match.index);
-    }
-    while ((match = payloadRegex.exec(text)) !== null) {
-        markers.push(match.index);
-    }
-    // If we have at least 2 markers, consider it raw FlexMD
-    if (markers.length >= 2) {
-        const start = Math.min(...markers);
-        const end = text.length;
-        detected.push({
-            kind: "raw_flexmd",
-            confidence: 0.7,
-            start,
-            end,
-            raw: text.substring(start, end)
-        });
-    }
-    return detected;
-}

package/dist/detection/extractor.d.ts

@@ -1,10 +0,0 @@
-import type { FlexDocument } from "../types.js";
-export interface ParseAnyResult {
-    flexDocs: FlexDocument[];
-    markdownSnippets: string[];
-    remainder: string;
-}
-/**
- * Parse any text and extract all FlexMD documents and Markdown snippets.
- */
-export declare function parseAny(text: string): ParseAnyResult;

package/dist/detection/extractor.js

@@ -1,54 +0,0 @@
-import { detectObjects } from "./detector.js";
-import { parseFlexMd } from "../parser.js";
-/**
- * Parse any text and extract all FlexMD documents and Markdown snippets.
- */
-export function parseAny(text) {
-    const detected = detectObjects(text);
-    const flexDocs = [];
-    const markdownSnippets = [];
-    for (const obj of detected) {
-        if (obj.kind === "flexmd_fence" && obj.inner) {
-            // Parse fenced FlexMD
-            try {
-                const doc = parseFlexMd(obj.inner);
-                flexDocs.push(doc);
-            }
-            catch {
-                // Parse failed, treat as markdown snippet
-                markdownSnippets.push(obj.inner);
-            }
-        }
-        else if (obj.kind === "flexdoc_json_fence" && obj.inner) {
-            // Parse JSON FlexDocument
-            try {
-                const doc = JSON.parse(obj.inner);
-                flexDocs.push(doc);
-            }
-            catch {
-                // Parse failed, skip
-            }
-        }
-        else if (obj.kind === "raw_flexmd") {
-            // Parse raw FlexMD
-            try {
-                const doc = parseFlexMd(obj.raw);
-                flexDocs.push(doc);
-            }
-            catch {
-                // Parse failed, treat as markdown snippet
-                markdownSnippets.push(obj.raw);
-            }
-        }
-    }
-    // Calculate remainder (text not covered by detected objects)
-    let remainder = text;
-    for (const obj of detected) {
-        remainder = remainder.replace(obj.raw, "");
-    }
-    return {
-        flexDocs,
-        markdownSnippets,
-        remainder: remainder.trim()
-    };
-}

package/dist/issues/build.d.ts

@@ -1,26 +0,0 @@
-import type { StrictnessOptions } from "../strictness/types.js";
-export type IssuesStatusCode = "missing_input" | "unclear_instructions" | "invalid_format" | "unsupported" | (string & {});
-export interface IssueItem {
-    issue: string;
-    path?: string;
-    expected?: string;
-    got?: string;
-    hint?: string;
-    [k: string]: string | undefined;
-}
-export interface BuildIssuesEnvelopeInput {
-    status: "error" | "partial";
-    code: IssuesStatusCode;
-    message: string;
-    issues: IssueItem[];
-    missingInputs?: string[];
-    clarificationsNeeded?: string[];
-    /** If provided, wraps output in a single container fence when strictness requires it. */
-    strictness?: StrictnessOptions;
-    /** Override fence language: "markdown" | "flexmd" (defaults from strictness.container) */
-    fence?: "markdown" | "flexmd";
-}
-/**
- * Build a Markdown-only issues envelope.
- */
-export declare function buildIssuesEnvelope(input: BuildIssuesEnvelopeInput): string;

package/dist/issues/build.js

@@ -1,62 +0,0 @@
-import { strictnessDefaults } from "../strictness/types.js";
-/**
- * Build a Markdown-only issues envelope.
- */
-export function buildIssuesEnvelope(input) {
-    const strict = input.strictness ? { ...strictnessDefaults(input.strictness.level), ...input.strictness } : undefined;
-    const fence = input.fence ?? resolveFence(strict);
-    const lines = [];
-    lines.push(`## Status`);
-    lines.push(`- status: ${input.status}`);
-    lines.push(`- code: ${input.code}`);
-    lines.push(`- message: ${input.message}`);
-    lines.push(``);
-    if (input.missingInputs && input.missingInputs.length) {
-        lines.push(`## Missing inputs`);
-        for (const mi of input.missingInputs)
-            lines.push(`- ${mi}`);
-        lines.push(``);
-    }
-    if (input.clarificationsNeeded && input.clarificationsNeeded.length) {
-        lines.push(`## Clarifications needed`);
-        for (const q of input.clarificationsNeeded)
-            lines.push(`- ${q}`);
-        lines.push(``);
-    }
-    lines.push(`## Issues`);
-    if (!input.issues.length) {
-        lines.push(`- issue: none`);
-    }
-    else {
-        for (const it of input.issues) {
-            lines.push(`- issue: ${it.issue}`);
-            emitField(lines, "path", it.path);
-            emitField(lines, "expected", it.expected);
-            emitField(lines, "got", it.got);
-            emitField(lines, "hint", it.hint);
-            for (const [k, v] of Object.entries(it)) {
-                if (k === "issue" || k === "path" || k === "expected" || k === "got" || k === "hint")
-                    continue;
-                emitField(lines, k, v);
-            }
-        }
-    }
-    let md = lines.join("\n").trimEnd() + "\n";
-    if (strict && strict.level >= 2) {
-        const lang = (fence === "flexmd") ? "flexmd" : "markdown";
-        md = `\`\`\`${lang}\n${md}\`\`\`\n`;
-    }
-    return md;
-}
-function emitField(lines, key, value) {
-    if (value == null || value === "")
-        return;
-    lines.push(`  ${key}: ${value}`);
-}
-function resolveFence(strict) {
-    if (!strict)
-        return "markdown";
-    if (strict.container === "flexmd_fence")
-        return "flexmd";
-    return "markdown";
-}

package/dist/md/lists.d.ts

@@ -1,14 +0,0 @@
-export interface ListItem {
-    text: string;
-    index?: number;
-    children: ListItem[];
-}
-export interface ParsedList {
-    kind: "list";
-    ordered: boolean;
-    items: ListItem[];
-}
-/**
- * Parses a flat list segment from Markdown into a nested structure.
- */
-export declare function parseNestedList(sectionMd: string): ParsedList | null;

package/dist/md/lists.js

@@ -1,33 +0,0 @@
-/**
- * Parses a flat list segment from Markdown into a nested structure.
- */
-export function parseNestedList(sectionMd) {
-    const lines = sectionMd.split("\n");
-    const listLines = lines
-        .map(l => ({ raw: l, indent: (l.match(/^\s*/)?.[0].length ?? 0) }))
-        .filter(x => /^\s*(-\s+|\d+\.\s+)/.test(x.raw));
-    if (!listLines.length)
-        return null;
-    const ordered = listLines.some(x => /^\s*\d+\.\s+/.test(x.raw));
-    const root = [];
-    const stack = [];
-    for (const { raw, indent } of listLines) {
-        const mO = raw.match(/^\s*(\d+)\.\s+(.*)$/);
-        const mU = raw.match(/^\s*-\s+(.*)$/);
-        const text = (mO?.[2] ?? mU?.[1] ?? "").trim();
-        const item = { text, children: [] };
-        if (mO)
-            item.index = Number(mO[1]);
-        while (stack.length && stack[stack.length - 1].indent >= indent) {
-            stack.pop();
-        }
-        if (!stack.length) {
-            root.push(item);
-        }
-        else {
-            stack[stack.length - 1].item.children.push(item);
-        }
-        stack.push({ indent, item });
-    }
-    return { kind: "list", ordered, items: root };
-}

package/dist/md/tables.d.ts

@@ -1,25 +0,0 @@
-export interface ParsedTable {
-    kind: "table" | "ordered_table";
-    by?: string;
-    columns: string[];
-    rows: string[][];
-}
-/**
- * Extracts all pipe table blocks from a markdown string.
- */
-export declare function extractPipeTables(md: string): string[];
-/**
- * Parses a single pipe table block into columns and rows.
- */
-export declare function parsePipeTable(block: string): {
-    columns: string[];
-    rows: string[][];
-} | null;
-export declare function normalizeHeader(s: string): string;
-/**
- * Enforces ordered table constraints (must have '#' column numbered 1..N).
- */
-export declare function enforceOrderedTable(table: {
-    columns: string[];
-    rows: string[][];
-}): string[];

package/dist/md/tables.js

@@ -1,72 +0,0 @@
-/**
- * Extracts all pipe table blocks from a markdown string.
- */
-export function extractPipeTables(md) {
-    const lines = md.split("\n");
-    const blocks = [];
-    let i = 0;
-    while (i < lines.length) {
-        const h = lines[i] ?? "";
-        const s = lines[i + 1] ?? "";
-        const looksHeader = h.includes("|");
-        const looksSep = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(s);
-        if (looksHeader && looksSep) {
-            const start = i;
-            i += 2;
-            while (i < lines.length && (lines[i] ?? "").includes("|") && (lines[i] ?? "").trim() !== "") {
-                i++;
-            }
-            const block = lines.slice(start, i).join("\n");
-            blocks.push(block);
-            continue;
-        }
-        i++;
-    }
-    return blocks;
-}
-/**
- * Parses a single pipe table block into columns and rows.
- */
-export function parsePipeTable(block) {
-    const lines = block.split("\n").map(l => l.trim()).filter(Boolean);
-    if (lines.length < 2)
-        return null;
-    const parseRow = (row) => {
-        let content = row;
-        if (content.startsWith("|"))
-            content = content.slice(1);
-        if (content.endsWith("|"))
-            content = content.slice(0, -1);
-        return content.split("|").map(c => c.trim());
-    };
-    const columns = parseRow(lines[0]);
-    const rows = lines.slice(2).map(parseRow);
-    for (const r of rows) {
-        while (r.length < columns.length)
-            r.push("");
-    }
-    return { columns, rows };
-}
-export function normalizeHeader(s) {
-    return s.trim().toLowerCase();
-}
-/**
- * Enforces ordered table constraints (must have '#' column numbered 1..N).
- */
-export function enforceOrderedTable(table) {
-    const issues = [];
-    if (!table.columns.length || normalizeHeader(table.columns[0]) !== "#") {
-        issues.push("ordered_table_missing_hash_column");
-        return issues;
-    }
-    // enforce 1..N
-    for (let i = 0; i < table.rows.length; i++) {
-        const cell = (table.rows[i]?.[0] ?? "").trim();
-        const n = Number(cell);
-        if (!Number.isInteger(n) || n !== i + 1) {
-            issues.push("ordered_table_bad_index_sequence");
-            break;
-        }
-    }
-    return issues;
-}

package/dist/ofs/extractor.d.ts

@@ -1,9 +0,0 @@
-import type { OutputFormatSpec, ExtractedResult } from "../types.js";
-export interface ExtractOptions {
-    /** Parse lists even for prose sections */
-    parseAllLists?: boolean;
-}
-/**
- * Extract structured data from Markdown based on an OutputFormatSpec.
- */
-export declare function extractOutput(md: string, spec: OutputFormatSpec, opts?: ExtractOptions): ExtractedResult;

package/dist/ofs/extractor.js

@@ -1,75 +0,0 @@
-import { buildOutline } from "../outline/builder.js";
-import { parseList } from "../parsers/lists.js";
-import { extractAllTables } from "../parsers/tables.js";
-/**
- * Extract structured data from Markdown based on an OutputFormatSpec.
- */
-export function extractOutput(md, spec, opts = {}) {
-    const outline = buildOutline(md);
-    const tables = extractAllTables(md);
-    // Index nodes by normalized title
-    const matches = collectMatches(outline.nodes);
-    const sectionsByName = {};
-    // Extract each section
-    for (const section of spec.sections) {
-        const key = normalizeTitle(section.name);
-        const nodes = matches.get(key) ?? [];
-        if (nodes.length === 0) {
-            // Section not found - could add to a "missing" array if needed
-            continue;
-        }
-        // Choose best node (highest level)
-        const chosen = chooseBestNode(nodes);
-        const body = chosen.content_md.trim();
-        const extracted = {
-            nodeKey: chosen.key,
-            nodeLevel: chosen.level,
-            md: body
-        };
-        // Parse lists if required by section kind or if parseAllLists is enabled
-        if (section.kind === "list" || section.kind === "ordered_list" || opts.parseAllLists) {
-            const list = parseList(body);
-            if (list) {
-                extracted.list = list;
-            }
-        }
-        sectionsByName[section.name] = extracted;
-    }
-    return {
-        outline,
-        sectionsByName,
-        tables
-    };
-}
-/**
- * Collect all nodes by normalized title.
- */
-function collectMatches(nodes) {
-    const map = new Map();
-    function visit(node) {
-        const key = normalizeTitle(node.title);
-        const existing = map.get(key) ?? [];
-        existing.push(node);
-        map.set(key, existing);
-        node.children.forEach(visit);
-    }
-    nodes.forEach(visit);
-    return map;
-}
-/**
- * Choose the best node from multiple matches.
- * Prefer highest-level heading (smallest level number).
- */
-function chooseBestNode(nodes) {
-    if (nodes.length === 1)
-        return nodes[0];
-    // Sort by level (ascending) and take first
-    const sorted = [...nodes].sort((a, b) => a.level - b.level);
-    return sorted[0];
-}
-/**
- * Normalize title for comparison: lowercase, remove trailing punctuation.
- */
-function normalizeTitle(t) {
-    return t.trim().replace(/[:\-–—]\s*$/, "").trim().toLowerCase();
-}

package/dist/ofs/issues.d.ts

@@ -1,14 +0,0 @@
-import type { IssuesEnvelope, FlexMdResponseMode } from "../types.js";
-/**
- * Detects if the response is an Issues envelope (Mode B).
- */
-export declare function detectIssuesEnvelope(md: string): boolean;
-/**
- * Historical alias for processResponseMarkdown.
- * @deprecated Use detectIssuesEnvelope
- */
-export declare function detectResponseMode(md: string): FlexMdResponseMode;
-/**
- * Parses a Markdown Issues envelope into a structured JSON object.
- */
-export declare function parseIssuesEnvelope(md: string): IssuesEnvelope | null;

package/dist/ofs/issues.js

@@ -1,92 +0,0 @@
-/**
- * Detects if the response is an Issues envelope (Mode B).
- */
-export function detectIssuesEnvelope(md) {
-    const hasStatus = /(^|\n)##\s+Status\s*$/im.test(md);
-    const hasIssuesHeading = /(^|\n)##\s+Issues\s*$/im.test(md);
-    const hasStatusLine = /(^|\n)-\s*status:\s*(error|partial)\s*$/im.test(md);
-    return hasStatus && hasIssuesHeading && hasStatusLine;
-}
-/**
- * Historical alias for processResponseMarkdown.
- * @deprecated Use detectIssuesEnvelope
- */
-export function detectResponseMode(md) {
-    return detectIssuesEnvelope(md) ? "issues" : "answer";
-}
-/**
- * Parses a Markdown Issues envelope into a structured JSON object.
- */
-export function parseIssuesEnvelope(md) {
-    if (detectResponseMode(md) !== "issues")
-        return null;
-    const statusBlock = sectionBody(md, "Status");
-    const issuesBlock = sectionBody(md, "Issues");
-    if (!statusBlock || !issuesBlock)
-        return null;
-    const statusKv = parseTopLevelKvBullets(statusBlock);
-    const status = {
-        status: statusKv["status"] ?? "error",
-        code: statusKv["code"] ?? "invalid_format",
-        message: statusKv["message"] ?? "An error occurred."
-    };
-    const missingInputs = parseSimpleList(sectionBody(md, "Missing inputs"));
-    const clarificationsNeeded = parseSimpleList(sectionBody(md, "Clarifications needed"));
-    const issues = parseIssueItems(issuesBlock);
-    return {
-        mode: "issues",
-        status,
-        missingInputs: missingInputs.length ? missingInputs : undefined,
-        clarificationsNeeded: clarificationsNeeded.length ? clarificationsNeeded : undefined,
-        issues
-    };
-}
-function sectionBody(md, heading) {
-    const rx = new RegExp(`(^|\\n)##\\s+${escapeRx(heading)}\\s*\\n([\\s\\S]*?)(\\n##\\s+|$)`, "i");
-    const m = md.match(rx);
-    return m ? (m[2] ?? "").trim() : null;
-}
-function parseTopLevelKvBullets(block) {
-    const out = {};
-    for (const line of block.split("\n")) {
-        const m = line.match(/^\s*-\s*([a-zA-Z0-9_-]+)\s*:\s*(.+?)\s*$/);
-        if (m)
-            out[m[1]] = m[2];
-    }
-    return out;
-}
-function parseSimpleList(block) {
-    if (!block)
-        return [];
-    const items = [];
-    for (const line of block.split("\n")) {
-        const m = line.match(/^\s*-\s+(.+?)\s*$/);
-        if (m)
-            items.push(m[1].trim());
-    }
-    return items;
-}
-function parseIssueItems(block) {
-    const lines = block.split("\n");
-    const items = [];
-    let current = null;
-    for (const line of lines) {
-        const top = line.match(/^\s*-\s*issue:\s*(.+?)\s*$/i);
-        if (top) {
-            if (current)
-                items.push(current);
-            current = { issue: top[1].trim() };
-            continue;
-        }
-        const sub = line.match(/^\s{2,}([a-zA-Z0-9_-]+)\s*:\s*(.+?)\s*$/);
-        if (sub && current) {
-            current[sub[1]] = sub[2].trim();
-        }
-    }
-    if (current)
-        items.push(current);
-    return items;
-}
-function escapeRx(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/dist/ofs/validator.d.ts

@@ -1,10 +0,0 @@
-import type { OutputFormatSpec } from "../types.js";
-export interface OfsValidationResult {
-    ok: boolean;
-    errors: string[];
-    warnings: string[];
-}
-/**
- * Validate Markdown output against an OutputFormatSpec.
- */
-export declare function validateOutput(md: string, spec: OutputFormatSpec): OfsValidationResult;