flex-md 3.5.0 → 4.1.0

package/dist/test-pipeline.js

@@ -1,53 +0,0 @@
-import { enforceFlexMd, parseOutputFormatSpec, detectResponseKind } from "./index.js";
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(`Assertion failed: ${message}`);
-    }
-}
-console.log("🧪 Running Pipeline & JSON Detection Tests\n");
-const spec = parseOutputFormatSpec(`
-## Output format
-- Answer — prose (required)
-- Reasoning — ordered list (optional)
-`);
-// 1. Detection Kind
-console.log("--- Detection Kind ---");
-const mdResp = "## Answer\nThis is an answer.";
-const kind1 = detectResponseKind(mdResp, spec);
-console.log("FlexMD Kind:", kind1.kind);
-assert(kind1.kind === "flexmd", "Should detect flexmd");
-const issuesResp = "## Status\n- status: error\n- code: fail\n- message: fail\n\n## Issues\n- issue: x";
-const kind2 = detectResponseKind(issuesResp, spec);
-console.log("Issues Kind:", kind2.kind);
-assert(kind2.kind === "issues", "Should detect issues");
-const plainResp = "Just some text.";
-const kind3 = detectResponseKind(plainResp, spec);
-console.log("Markdown Kind:", kind3.kind);
-assert(kind3.kind === "markdown", "Should detect markdown");
-// 2. JSON fixing
-console.log("\n--- JSON Fixing ---");
-const jsonResp = "```json\n{\n  \"Answer\": \"Parsed from JSON\",\n  \"Reasoning\": [\"Step 1\", \"Step 2\"]\n}\n```";
-const resultJson = enforceFlexMd(jsonResp, spec, { level: 1 });
-console.log("JSON Fixed OK:", resultJson.ok);
-console.log("JSON Fixed Content:\n", resultJson.extracted?.sectionsByName["Answer"]?.md);
-assert(resultJson.ok === true, "Enforce should succeed with fixed JSON");
-assert(!!resultJson.extracted?.sectionsByName["Answer"]?.md.includes("Parsed from JSON"), "Should extract from fixed JSON");
-assert(resultJson.extracted?.sectionsByName["Reasoning"]?.list?.items.length === 2, "Should extract list from fixed JSON");
-// 3. Raw JSON object
-console.log("\n--- Raw JSON Object ---");
-const rawJson = "{\"Answer\": \"Raw JSON\"}";
-const resultRaw = enforceFlexMd(rawJson, spec, { level: 1 });
-console.log("Raw JSON Fixed OK:", resultRaw.ok);
-assert(resultRaw.ok === true, "Should fix raw JSON");
-// 4. Missing sections fixing
-console.log("\n--- Missing Sections ---");
-// The fixer (repairToMarkdownLevel) SHOULD add missing required sections.
-const failingResp = "## SomeOtherSection\nContent";
-const resultFixed = enforceFlexMd(failingResp, spec, { level: 1 });
-console.log("Auto-Repaired OK:", resultFixed.ok);
-console.log("Repaired Content Contains 'Answer':", resultFixed.outputText.includes("## Answer"));
-console.log("Repaired Content Contains 'None':", resultFixed.outputText.includes("None"));
-assert(resultFixed.ok === true, "Should be ok if required sections are auto-repaired");
-assert(resultFixed.outputText.includes("## Answer"), "Should have added 'Answer' heading");
-assert(resultFixed.outputText.includes("None"), "Should have filled with 'None'");
-console.log("\n✅ Pipeline Tests Passed");

package/dist/test-runner.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test-runner.js

@@ -1,331 +0,0 @@
-import { 
-// Layer A
-parseFlexMd, stringifyFlexMd, validateFlexMd, 
-// Layer B
-parseOutputFormatSpec, stringifyOutputFormatSpec, enrichInstructions, validateMarkdownAgainstOfs as validateOutput, extractFromMarkdown as extractOutput, 
-// Outline
-buildOutline, renderOutline, 
-// Parsers
-parseNestedList as parseList, parsePipeTable, extractPipeTables as extractAllTables, enforceOrderedTable, 
-// Strictness
-strictnessDefaults, 
-// Layer C
-detectObjects, parseAny } from "./index.js";
-let passed = 0;
-let failed = 0;
-function test(name, fn) {
-    try {
-        fn();
-        console.log(`✅ ${name}`);
-        passed++;
-    }
-    catch (e) {
-        console.error(`❌ ${name}`);
-        console.error(e);
-        failed++;
-    }
-}
-function assert(condition, message) {
-    if (!condition) {
-        throw new Error(`Assertion failed: ${message}`);
-    }
-}
-console.log("🧪 Running FlexMD v1.1 Tests\n");
-// ============================================================================
-// Layer A Tests
-// ============================================================================
-console.log("📦 Layer A - FlexMD Frames\n");
-test("Parse basic FlexMD frame", () => {
-    const md = `[[message role=user id=m1]]
-@tags: auth, login
-Hello world
-`;
-    const doc = parseFlexMd(md);
-    assert(doc.frames.length === 1, "Should have 1 frame");
-    assert(doc.frames[0].type === "message", "Type should be message");
-    assert(doc.frames[0].role === "user", "Role should be user");
-    assert(Array.isArray(doc.frames[0].meta?.tags), "Tags should be array");
-});
-test("Stringify FlexMD frame", () => {
-    const doc = {
-        frames: [{
-                type: "message",
-                role: "user",
-                id: "m1",
-                meta: { tags: ["auth", "login"] },
-                body_md: "Hello world\n"
-            }]
-    };
-    const md = stringifyFlexMd(doc);
-    assert(md.includes("[[message"), "Should contain frame header");
-    assert(md.includes("@tags:"), "Should contain meta");
-});
-test("Parse with type inference", () => {
-    const md = `[[message]]
-@priority: 5
-@enabled: true
-@value: null
-Body text
-`;
-    const doc = parseFlexMd(md, { metaTypeMode: "infer" });
-    assert(doc.frames[0].meta?.priority === 5, "Should infer number");
-    assert(doc.frames[0].meta?.enabled === true, "Should infer boolean");
-    assert(doc.frames[0].meta?.value === null, "Should infer null");
-});
-test("Validate FlexMD", () => {
-    const valid = `[[message role=user]]
-Hello
-`;
-    const result = validateFlexMd(valid);
-    assert(result.valid === true, "Should be valid");
-});
-// ============================================================================
-// Layer B Tests
-// ============================================================================
-console.log("\n📋 Layer B - Output Format Spec\n");
-test("Parse OFS", () => {
-    const md = `## Output format (Markdown)
-Include these sections somewhere (order does not matter):
-
-- Short answer — prose
-- Reasoning — ordered list
-- Assumptions — list
-`;
-    const spec = parseOutputFormatSpec(md);
-    assert(spec !== null, "Spec should not be null");
-    assert(spec.sections.length === 3, "Should have 3 sections");
-    assert(spec.sections[0].name === "Short answer", "First section name");
-    assert(spec.sections[0].kind === "prose", "First section kind");
-    assert(spec.sections[1].kind === "ordered_list", "Second section kind");
-});
-test("Stringify OFS", () => {
-    const spec = {
-        descriptorType: "output_format_spec",
-        format: "markdown",
-        sectionOrderMatters: false,
-        sections: [
-            { name: "Answer", kind: "prose" }
-        ],
-        tablesOptional: true,
-        tables: [],
-        emptySectionValue: "None"
-    };
-    const md = stringifyOutputFormatSpec(spec);
-    assert(md.includes("Answer — prose"), "Should contain section");
-    assert(md.includes("None"), "Should contain empty value");
-});
-test("Enrich instructions", () => {
-    const spec = {
-        descriptorType: "output_format_spec",
-        format: "markdown",
-        sectionOrderMatters: false,
-        sections: [
-            { name: "Steps", kind: "ordered_list" },
-            { name: "Notes", kind: "list" }
-        ],
-        tablesOptional: true,
-        tables: [],
-        emptySectionValue: "None"
-    };
-    const instructions = enrichInstructions(spec, strictnessDefaults(1));
-    assert(instructions.includes("numbered items"), "Should mention ordered lists");
-    assert(instructions.includes("bullets"), "Should mention lists");
-    assert(instructions.includes("None"), "Should mention empty value");
-});
-test("Validate output against OFS", () => {
-    const spec = {
-        descriptorType: "output_format_spec",
-        format: "markdown",
-        sectionOrderMatters: false,
-        sections: [
-            { name: "Answer", kind: "prose" }
-        ],
-        tablesOptional: true,
-        tables: []
-    };
-    const md = `## Answer\nThe answer is 42.`;
-    const result = validateOutput(md, spec, strictnessDefaults(1));
-    assert(result.ok === true, "Should validate successfully");
-});
-test("Extract output from OFS", () => {
-    const spec = {
-        descriptorType: "output_format_spec",
-        format: "markdown",
-        sectionOrderMatters: false,
-        sections: [
-            { name: "Answer", kind: "prose" },
-            { name: "Steps", kind: "ordered_list" }
-        ],
-        tablesOptional: true,
-        tables: []
-    };
-    const md = `## Answer
-The answer is 42.
-
-## Steps
-1. First step
-2. Second step
-`;
-    const extracted = extractOutput(md, spec, strictnessDefaults(1));
-    assert(extracted.sectionsByName["Answer"].md.includes("42"), "Should extract answer");
-    assert(extracted.sectionsByName["Steps"].list?.ordered === true, "Should parse ordered list");
-    assert(extracted.sectionsByName["Steps"].list?.items.length === 2, "Should have 2 items");
-});
-// ============================================================================
-// Outline Tests
-// ============================================================================
-console.log("\n🌳 Outline & Tree Building\n");
-test("Build outline from headings", () => {
-    const md = `# Title
-Content
-
-## Section 1
-More content
-
-### Subsection 1.1
-Details
-
-## Section 2
-Other content
-`;
-    const outline = buildOutline(md);
-    assert(outline.nodes.length === 1, "Should have 1 root node");
-    assert(outline.nodes[0].title === "Title", "Root title");
-    assert(outline.nodes[0].children.length === 2, "Should have 2 children");
-    assert(outline.nodes[0].children[0].children.length === 1, "First child has 1 child");
-});
-test("Render outline back to Markdown", () => {
-    const outline = {
-        type: "md_outline",
-        nodes: [{
-                title: "Title",
-                level: 1,
-                key: "title",
-                content_md: "Content\n",
-                children: [{
-                        title: "Section",
-                        level: 2,
-                        key: "section",
-                        content_md: "More\n",
-                        children: []
-                    }]
-            }]
-    };
-    const md = renderOutline(outline);
-    assert(md.includes("# Title"), "Should have h1");
-    assert(md.includes("## Section"), "Should have h2");
-    assert(!md.includes("key"), "Should not include internal keys");
-});
-// ============================================================================
-// Parser Tests
-// ============================================================================
-console.log("\n📝 List & Table Parsers\n");
-test("Parse unordered list", () => {
-    const md = `- Item 1
-  - Nested 1.1
-- Item 2
-`;
-    const list = parseList(md);
-    assert(list !== null, "Should parse list");
-    assert(list.ordered === false, "Should be unordered");
-    assert(list.items.length === 2, "Should have 2 items");
-    assert(list.items[0].children.length === 1, "First item has 1 child");
-});
-test("Parse ordered list", () => {
-    const md = `1. First
-   1. Sub-first
-2. Second
-`;
-    const list = parseList(md);
-    assert(list !== null, "Should parse list");
-    assert(list.ordered === true, "Should be ordered");
-    assert(list.items.length === 2, "Should have 2 items");
-    assert(list.items[0].index === 1, "First item index");
-});
-test("Parse pipe table", () => {
-    const md = `| Name | Age |
-|------|-----|
-| Alice | 30 |
-| Bob | 25 |
-`;
-    const table = parsePipeTable(md);
-    assert(table !== null, "Should parse table");
-    assert(table.columns.length === 2, "Should have 2 columns");
-    assert(table.rows.length === 2, "Should have 2 rows");
-});
-test("Parse ordered table", () => {
-    const md = `| # | Task | Status |
-|---|------|--------|
-| 1 | Do it | Done |
-| 2 | Check | Pending |
-`;
-    const table = parsePipeTable(md);
-    assert(table !== null, "Should parse table");
-    const issues = enforceOrderedTable(table);
-    assert(issues.length === 0, "Should have no ordered table issues");
-    assert(table.columns[0] === "#", "First column should be #");
-});
-test("Extract all tables", () => {
-    const md = `Some text
-
-| A | B |
-|---|---|
-| 1 | 2 |
-
-More text
-
-| C | D |
-|---|---|
-| 3 | 4 |
-`;
-    const tables = extractAllTables(md);
-    assert(tables.length === 2, "Should find 2 tables");
-});
-// ============================================================================
-// Layer C Tests
-// ============================================================================
-console.log("\n🔍 Layer C - Detection & Extraction\n");
-test("Detect flexmd fence", () => {
-    const text = `Some text
-\`\`\`flexmd
-[[message]]
-Hello
-\`\`\`
-More text
-`;
-    const detected = detectObjects(text);
-    assert(detected.length > 0, "Should detect object");
-    assert(detected[0].kind === "flexmd_fence", "Should be flexmd fence");
-    assert(detected[0].confidence === 1.0, "Should have high confidence");
-});
-test("Detect JSON FlexDocument", () => {
-    const text = `\`\`\`json
-{"frames": [{"type": "message", "body_md": "Hello"}]}
-\`\`\`
-`;
-    const detected = detectObjects(text);
-    assert(detected.length > 0, "Should detect object");
-    assert(detected[0].kind === "flexdoc_json_fence", "Should be JSON FlexDoc");
-});
-test("Parse any text", () => {
-    const text = `Random text
-\`\`\`flexmd
-[[message role=user]]
-Hello
-\`\`\`
-More text
-`;
-    const result = parseAny(text);
-    assert(result.flexDocs.length === 1, "Should extract 1 FlexDoc");
-    assert(result.flexDocs[0].frames.length === 1, "Should have 1 frame");
-});
-// ============================================================================
-// Summary
-// ============================================================================
-console.log("\n" + "=".repeat(50));
-console.log(`✅ Passed: ${passed}`);
-console.log(`❌ Failed: ${failed}`);
-console.log("=" + "=".repeat(50));
-if (failed > 0) {
-    throw new Error("Tests failed");
-}

package/dist/test-strictness.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test-strictness.js

@@ -1,213 +0,0 @@
-import { parseOutputFormatSpec, processResponseMarkdown, strictnessDefaults } from "../src/index.js";
-const specText = `
-## Output format (Markdown)
-Include these sections somewhere (order does not matter):
-
-- Short answer — prose
-- Long answer — prose
-- Reasoning — ordered list
-- Assumptions — list
-- Unknowns — list
-
-tables:
-- (property, value — table)
-
-empty sections:
-- If a section is empty, write \`None\`.
-`;
-const spec = parseOutputFormatSpec(specText);
-// --- L0 Test ---
-console.log("--- Level 0 Test ---");
-const l0Response = `
-I thought about it.
-## Short answer
-Yes, it works.
-
-## Unknowns
-- None so far.
-`;
-const l0Result = processResponseMarkdown(l0Response, spec, strictnessDefaults(0));
-console.log("L0 OK:", l0Result.ok);
-console.log("L0 Issues:", l0Result.issues);
-// --- L1 Test ---
-console.log("\n--- Level 1 Test ---");
-const l1Response = `
-## Short answer
-Yes.
-
-## Long answer
-Full details.
-
-## Reasoning
-1. Step one.
-2. Step two.
-
-## Assumptions
-- Assumption A.
-
-## Unknowns
-None
-`;
-const l1Result = processResponseMarkdown(l1Response, spec, strictnessDefaults(1));
-console.log("L1 OK:", l1Result.ok);
-console.log("L1 Issues:", l1Result.issues);
-// --- L2 Test ---
-console.log("\n--- Level 2 Test ---");
-const l2Response = `
-Some chatter before.
-\`\`\`markdown
-## Short answer
-Yes.
-## Long answer
-None
-## Reasoning
-1. A
-## Assumptions
-None
-## Unknowns
-None
-\`\`\`
-Some chatter after.
-`;
-const l2Result = processResponseMarkdown(l2Response, spec, strictnessDefaults(2));
-console.log("L2 OK (should be false if chatter exists):", l2Result.ok);
-console.log("L2 Issues (should include 'content_outside_container'):", l2Result.issues);
-const l2ResponseClean = `\`\`\`markdown
-## Short answer
-Yes.
-## Long answer
-None
-## Reasoning
-1. A
-## Assumptions
-None
-## Unknowns
-None
-\`\`\``;
-const l2ResultClean = processResponseMarkdown(l2ResponseClean, spec, strictnessDefaults(2));
-console.log("L2 Clean OK:", l2ResultClean.ok);
-// --- L3 Test ---
-console.log("\n--- Level 3 Test ---");
-const l3Response = `\`\`\`markdown
-## Short answer
-Data processed.
-## Long answer
-None
-## Reasoning
-1. Step
-## Assumptions
-None
-## Unknowns
-None
-
-\`\`\`json
-{ "status": "success", "val": 42 }
-\`\`\`
-\`\`\``;
-// The regex in processor.ts is: /```json\s*\n([\s\S]*?)\n```/i
-// Let's see why it failed. Ah, the innerMarkdown was extracted but maybe the nested blocks were messed up.
-// Actually, l3Result returned issues: [ 'content_outside_container', 'json_payload_missing' ]
-// content_outside_container is due to the trailing \`\`\` outside if the first one was matched greedily? 
-// No, regex is non-greedy in container.ts: /\`\`\`" + fenceLang + "\\s*\\n([\\s\\S]*?)\\n\`\`\`/i
-// Wait, the container extractor in container.ts uses: /\`\`\`" + fenceLang + "\\s*\\n([\\s\\S]*?)\\n\`\`\`/i
-// In my L3 test:
-// \`\`\`markdown
-// ...
-// \`\`\`json
-// ...
-// \`\`\`
-// \`\`\`
-// The second to last \`\`\` matches the end of the markdown block. The last \`\`\` is "outside".
-const l3ResponseFixed = `\`\`\`markdown
-## Short answer
-Data processed.
-## Long answer
-None
-## Reasoning
-1. Step
-## Assumptions
-None
-## Unknowns
-None
-
-\`\`\`json
-{ "status": "success", "val": 42 }
-\`\`\`
-\`\`\``;
-// In this one there are two closing fences.
-const l3ResponseSimple = `\`\`\`markdown
-## Short answer
-Data processed.
-## Long answer
-None
-## Reasoning
-1. Step
-## Assumptions
-None
-## Unknowns
-None
-
-\`\`\`json
-{ "status": "success", "val": 42 }
-\`\`\`
-\`\`\``;
-// Let's try again with a simpler L3 mock
-const l3ResponseSuccess = `\`\`\`markdown
-## Short answer
-Done.
-## Long answer
-None
-## Reasoning
-1. A
-## Assumptions
-None
-## Unknowns
-None
-
-\`\`\`json
-{"ok": true}
-\`\`\`
-\`\`\``;
-const lResult3 = processResponseMarkdown(l3ResponseSuccess, spec, strictnessDefaults(3));
-console.log("L3 Success OK:", lResult3.ok);
-console.log("L3 Issues:", lResult3.issues);
-// --- Semi-Strict Test ---
-console.log("\n--- Semi-Strict Test ---");
-const semiStrictSpecText = `
-## Output format
-- Answer — prose (required)
-- Extra — list (optional)
-`;
-const semiStrictSpec = parseOutputFormatSpec(semiStrictSpecText);
-const semiStrictResponse = `
-## Answer
-This is the answer.
-`;
-// Level 1 defaults to requireAllSections: true. 
-// But "Extra" is marked (optional).
-const semiStrictResult = processResponseMarkdown(semiStrictResponse, semiStrictSpec, { level: 1 });
-console.log("Semi-Strict Missing Optional OK:", semiStrictResult.ok); // Should be true
-console.log("Semi-Strict Issues:", semiStrictResult.issues);
-const semiStrictResponseError = `
-## Extra
-- Something
-`;
-const semiStrictResultError = processResponseMarkdown(semiStrictResponseError, semiStrictSpec, { level: 1 });
-console.log("Semi-Strict Missing Required OK:", semiStrictResultError.ok); // Should be false
-console.log("Semi-Strict Issues (should have missing_section:Answer):", semiStrictResultError.issues.map((i) => i.code));
-// --- Mode B (Issues Envelope) Test ---
-console.log("\n--- Mode B Test ---");
-const modeBResponse = `
-## Status
-- status: error
-- code: missing_input
-- message: The user forgot the org_id.
-
-## Issues
-- issue: missing_org_id
-  hint: please provide org_id
-`;
-const modeBResult = processResponseMarkdown(modeBResponse, semiStrictSpec, { level: 1 });
-console.log("Mode B Detected:", !!modeBResult.issuesEnvelope);
-console.log("Mode B Status Code:", modeBResult.issuesEnvelope?.status.code);
-console.log("Mode B OK (should be false for error status):", modeBResult.ok);

package/dist/util.d.ts

@@ -1,5 +0,0 @@
-export declare function isBlank(s: unknown): boolean;
-export declare function isEmptyObject(o: unknown): boolean;
-export declare function splitTokensPreservingQuotes(input: string): string[];
-export declare function unquote(s: string): string;
-export declare function quoteIfNeeded(value: string): string;

package/dist/util.js

@@ -1,64 +0,0 @@
-export function isBlank(s) {
-    return typeof s !== "string" || s.trim().length === 0;
-}
-export function isEmptyObject(o) {
-    if (!o || typeof o !== "object")
-        return true;
-    return Object.keys(o).length === 0;
-}
-export function splitTokensPreservingQuotes(input) {
-    // Splits by whitespace, but keeps "quoted strings" and 'quoted strings'
-    // Example: key="hello world" -> single token
-    const tokens = [];
-    let i = 0;
-    while (i < input.length) {
-        while (i < input.length && /\s/.test(input[i]))
-            i++;
-        if (i >= input.length)
-            break;
-        const ch = input[i];
-        if (ch === '"' || ch === "'") {
-            const quote = ch;
-            i++;
-            let buf = "";
-            while (i < input.length) {
-                const c = input[i];
-                if (c === "\\" && i + 1 < input.length) {
-                    // minimal escape support
-                    buf += input[i + 1];
-                    i += 2;
-                    continue;
-                }
-                if (c === quote) {
-                    i++;
-                    break;
-                }
-                buf += c;
-                i++;
-            }
-            tokens.push(quote + buf + quote);
-            continue;
-        }
-        // unquoted token
-        let start = i;
-        while (i < input.length && !/\s/.test(input[i]))
-            i++;
-        tokens.push(input.slice(start, i));
-    }
-    return tokens;
-}
-export function unquote(s) {
-    const t = s.trim();
-    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
-        return t.slice(1, -1);
-    }
-    return t;
-}
-export function quoteIfNeeded(value) {
-    // Only quote if whitespace or special chars likely to break header tokenization
-    if (/[\s\]]/.test(value) || value.includes('"') || value.includes("'")) {
-        // Use JSON-style quoting for safety
-        return JSON.stringify(value);
-    }
-    return value;
-}

package/dist/validate/policy.d.ts

@@ -1,10 +0,0 @@
-import { Enforcement, SemiStrictPolicy } from "../strictness/types.js";
-import { ValidationIssue } from "./types.js";
-export declare function enforcementToSeverity(e: Enforcement): "error" | "warning";
-/**
- * Decide whether to emit an issue:
- * - "ignore" => return null
- * - "warn"/"error" => return ValidationIssue with chosen severity
- */
-export declare function makeIssue(policy: SemiStrictPolicy | undefined, key: keyof SemiStrictPolicy, fallback: Enforcement, issue: Omit<ValidationIssue, "severity">): ValidationIssue | null;
-export declare function hasErrors(issues: ValidationIssue[]): boolean;