flex-md 3.2.0 → 4.0.0

package/dist/index.cjs

@@ -1,3 +1,62 @@
-// Auto-generated CJS bridge for flex-md
-const m = await import('./index.js');
-module.exports = m;
+"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.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.validateFormat = exports.parseOutputFormatSpec = exports.buildOutline = void 0;
+// Core SFMD Types
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./strictness/types.js"), exports);
+// Shared MD Parsing
+__exportStar(require("./md/parse.js"), exports);
+var outline_js_1 = require("./md/outline.js");
+Object.defineProperty(exports, "buildOutline", { enumerable: true, get: function () { return outline_js_1.buildOutline; } });
+// Output Format Spec (OFS)
+var parser_js_1 = require("./ofs/parser.js");
+Object.defineProperty(exports, "parseOutputFormatSpec", { enumerable: true, get: function () { return parser_js_1.parseOutputFormatSpec; } });
+Object.defineProperty(exports, "validateFormat", { enumerable: true, get: function () { return parser_js_1.validateFormat; } });
+var stringify_js_1 = require("./ofs/stringify.js");
+Object.defineProperty(exports, "stringifyOutputFormatSpec", { enumerable: true, get: function () { return stringify_js_1.stringifyOutputFormatSpec; } });
+var enricher_js_1 = require("./ofs/enricher.js");
+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.js");
+Object.defineProperty(exports, "validateMarkdownAgainstOfs", { enumerable: true, get: function () { return validate_js_1.validateMarkdownAgainstOfs; } });
+var compliance_js_1 = require("./validate/compliance.js");
+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.js");
+Object.defineProperty(exports, "checkConnection", { enumerable: true, get: function () { return connection_js_1.checkConnection; } });
+var extract_js_1 = require("./extract/extract.js");
+Object.defineProperty(exports, "extractFromMarkdown", { enumerable: true, get: function () { return extract_js_1.extractFromMarkdown; } });
+// Processor & Fallback
+var processor_js_1 = require("./strictness/processor.js");
+Object.defineProperty(exports, "processResponseMarkdown", { enumerable: true, get: function () { return processor_js_1.processResponseMarkdown; } });
+var issuesEnvelope_js_1 = require("./ofs/issuesEnvelope.js");
+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.js");
+Object.defineProperty(exports, "detectResponseKind", { enumerable: true, get: function () { return kind_js_1.detectResponseKind; } });
+var repair_js_1 = require("./pipeline/repair.js");
+Object.defineProperty(exports, "repairToMarkdownLevel", { enumerable: true, get: function () { return repair_js_1.repairToMarkdownLevel; } });
+var enforce_js_1 = require("./pipeline/enforce.js");
+Object.defineProperty(exports, "enforceFlexMd", { enumerable: true, get: function () { return enforce_js_1.enforceFlexMd; } });
+// JSON Detection
+__exportStar(require("./detect/json/index.js"), exports);
+// Token Estimation
+__exportStar(require("./tokens/index.js"), exports);

package/dist/index.d.ts

@@ -1,11 +1,13 @@
 export * from "./types.js";
 export * from "./strictness/types.js";
 export * from "./md/parse.js";
+export { buildOutline } from "./md/outline.js";
 export { parseOutputFormatSpec, validateFormat } from "./ofs/parser.js";
 export { stringifyOutputFormatSpec } from "./ofs/stringify.js";
 export { buildMarkdownGuidance, enrichInstructions, enrichInstructionsWithFlexMd } from "./ofs/enricher.js";
 export { validateMarkdownAgainstOfs } from "./validate/validate.js";
 export { checkCompliance, hasFlexMdContract } from "./validate/compliance.js";
+export { checkConnection } from "./validate/connection.js";
 export { extractFromMarkdown } from "./extract/extract.js";
 export { processResponseMarkdown } from "./strictness/processor.js";
 export { parseIssuesEnvelope, buildIssuesEnvelope, buildIssuesEnvelopeAuto } from "./ofs/issuesEnvelope.js";
@@ -13,3 +15,4 @@ export { detectResponseKind } from "./pipeline/kind.js";
 export { repairToMarkdownLevel } from "./pipeline/repair.js";
 export { enforceFlexMd } from "./pipeline/enforce.js";
 export * from "./detect/json/index.js";
+export * from "./tokens/index.js";

package/dist/index.js

@@ -3,6 +3,7 @@ export * from "./types.js";
 export * from "./strictness/types.js";
 // Shared MD Parsing
 export * from "./md/parse.js";
+export { buildOutline } from "./md/outline.js";
 // Output Format Spec (OFS)
 export { parseOutputFormatSpec, validateFormat } from "./ofs/parser.js";
 export { stringifyOutputFormatSpec } from "./ofs/stringify.js";
@@ -10,6 +11,7 @@ export { buildMarkdownGuidance, enrichInstructions, enrichInstructionsWithFlexMd
 // Validation & Extraction
 export { validateMarkdownAgainstOfs } from "./validate/validate.js";
 export { checkCompliance, hasFlexMdContract } from "./validate/compliance.js";
+export { checkConnection } from "./validate/connection.js";
 export { extractFromMarkdown } from "./extract/extract.js";
 // Processor & Fallback
 export { processResponseMarkdown } from "./strictness/processor.js";
@@ -20,3 +22,5 @@ export { repairToMarkdownLevel } from "./pipeline/repair.js";
 export { enforceFlexMd } from "./pipeline/enforce.js";
 // JSON Detection
 export * from "./detect/json/index.js";
+// Token Estimation
+export * from "./tokens/index.js";

package/dist/md/outline.d.ts

@@ -1,6 +1,9 @@
-import type { MdOutline } from "../types.js";
+import { MdOutline } from "../types.js";
 /**
- * Builds a nested outline tree from Markdown headings.
- * Supports any heading level and captures content between headings.
+ * Builds a nested tree of headings (outline) from Markdown text.
  */
 export declare function buildOutline(md: string): MdOutline;
+/**
+ * Slugifies a string into an internal key.
+ */
+export declare function slugify(text: string): string;

package/dist/md/outline.js

@@ -1,67 +1,45 @@
+import { parseHeadingsAndSections } from "./parse.js";
 /**
- * Builds a nested outline tree from Markdown headings.
- * Supports any heading level and captures content between headings.
+ * Builds a nested tree of headings (outline) from Markdown text.
  */
 export function buildOutline(md) {
-    const lines = md.split("\n");
-    const headings = [];
-    for (let i = 0; i < lines.length; i++) {
-        const m = (lines[i] ?? "").match(/^(#{1,6})\s+(.+?)\s*$/);
-        if (m) {
-            headings.push({ idx: i, level: m[1].length, title: cleanTitle(m[2]) });
-        }
-    }
-    if (!headings.length) {
-        return { type: "md_outline", nodes: [] };
-    }
-    const nodes = [];
+    const sections = parseHeadingsAndSections(md);
+    const roots = [];
     const stack = [];
-    for (let h = 0; h < headings.length; h++) {
-        const cur = headings[h];
-        const next = headings[h + 1];
-        const contentStart = cur.idx + 1;
-        const contentEnd = next ? next.idx : lines.length;
-        const content_md = lines.slice(contentStart, contentEnd).join("\n").trimEnd() + "\n";
+    for (const s of sections) {
+        const h = s.heading;
         const node = {
-            title: cur.title,
-            level: cur.level,
-            key: "",
-            content_md,
+            title: h.name,
+            level: h.level,
+            key: h.norm,
+            content_md: s.body,
             children: []
         };
-        while (stack.length && stack[stack.length - 1].level >= node.level) {
+        // 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) {
-            nodes.push(node);
+        if (stack.length === 0) {
+            roots.push(node);
         }
         else {
             stack[stack.length - 1].children.push(node);
         }
         stack.push(node);
     }
-    assignKeys(nodes);
-    return { type: "md_outline", nodes };
-}
-function cleanTitle(t) {
-    return t.trim().replace(/[:\-–—]\s*$/, "").trim();
-}
-function slugify(t) {
-    return t.toLowerCase()
-        .replace(/[:\-–—]+$/g, "")
-        .replace(/\s+/g, "_")
-        .replace(/[^a-z0-9_]/g, "")
-        .replace(/_+/g, "_")
-        .replace(/^_+|_+$/g, "");
-}
-function assignKeys(nodes) {
-    const seen = new Map();
-    const visit = (n) => {
-        const base = slugify(n.title) || "section";
-        const count = (seen.get(base) ?? 0) + 1;
-        seen.set(base, count);
-        n.key = count === 1 ? base : `${base}__${count}`;
-        n.children.forEach(visit);
+    return {
+        type: "md_outline",
+        nodes: roots
     };
-    nodes.forEach(visit);
+}
+/**
+ * Slugifies a string into an internal key.
+ */
+export function slugify(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/[\s_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
 }

package/dist/md/parse.js

@@ -28,17 +28,28 @@ export function extractFencedBlocks(text) {
     return blocks;
 }
 export function parseHeadingsAndSections(md) {
-    const rx = /^(#{1,6})\s+(.+?)\s*$/gm;
+    // Standard headings #... and alternative ===key
+    const rx = /^((?:#{1,6})\s+(.+?)\s*|===(.+?)\s*)$/gm;
     const headings = [];
     let m;
     while ((m = rx.exec(md)) !== null) {
-        const hashes = m[1] ?? "";
-        const name = (m[2] ?? "").trim();
+        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 {
+            const hashes = (full.match(/^#+/) ?? [""])[0];
+            level = hashes.length;
+            name = (m[2] ?? "").trim();
+        }
         const raw = m[0] ?? "";
         const start = m.index;
         const end = start + raw.length;
         headings.push({
-            level: hashes.length,
+            level,
             raw,
             name,
             norm: normalizeName(name),

package/dist/ofs/parser.js

@@ -96,36 +96,53 @@ export function parseOutputFormatSpec(md, opts = {}) {
     const tables = [];
     let emptySectionValue;
     let inTables = false;
+    let currentSection = null;
     for (const rawLine of block.split("\n")) {
         const line = rawLine.trim();
         if (/^tables\b/i.test(line)) {
             inTables = true;
+            currentSection = null;
             continue;
         }
         if (/^empty sections\b/i.test(line)) {
             inTables = false;
+            currentSection = null;
             continue;
         }
         // Empty section rule
         const mNone = line.match(/write\s+`([^`]+)`/i);
         if (/empty/i.test(line) && mNone) {
             emptySectionValue = mNone[1];
+            currentSection = null;
             continue;
         }
         // bullet items
         const bullet = line.match(/^- (.+)$/);
-        if (!bullet)
-            continue;
-        const item = bullet[1];
-        if (inTables) {
-            const t = parseTableDecl(item);
-            if (t)
-                tables.push(t);
+        if (bullet) {
+            const item = bullet[1];
+            if (inTables) {
+                const t = parseTableDecl(item);
+                if (t)
+                    tables.push(t);
+                currentSection = null;
+            }
+            else {
+                const s = parseSectionDecl(item, !!opts.allowDelimiterFallbacks);
+                if (s) {
+                    sections.push(s);
+                    currentSection = s;
+                }
+                else {
+                    currentSection = null;
+                }
+            }
             continue;
         }
-        const s = parseSectionDecl(item, !!opts.allowDelimiterFallbacks);
-        if (s)
-            sections.push(s);
+        // If not a bullet and we have a current section, it's an instruction
+        if (currentSection && line.length > 0) {
+            const existing = currentSection.instruction || "";
+            currentSection.instruction = existing ? `${existing} ${line}` : line;
+        }
     }
     if (!sections.length)
         return null;
@@ -169,6 +186,10 @@ function normalizeSectionKind(rest) {
         return "list";
     if (r.includes("prose") || r.includes("text"))
         return "text";
+    if (r.includes("ordered") && r.includes("table"))
+        return "ordered_table";
+    if (r.includes("table"))
+        return "table";
     return null;
 }
 function parseTableDecl(item) {

package/dist/tokens/auto-fix.d.ts

@@ -0,0 +1,10 @@
+import type { AutoFixResult, Improvement } from './types.js';
+import type { OutputFormatSpec } from '../types.js';
+/**
+ * Automatically apply fixable improvements
+ */
+export declare function autoFix(spec: OutputFormatSpec, improvements: Improvement[], options?: {
+    applyQuickWinsOnly?: boolean;
+    maxPriority?: Improvement['priority'];
+    skipManual?: boolean;
+}): AutoFixResult;

package/dist/tokens/auto-fix.js

@@ -0,0 +1,56 @@
+/**
+ * Automatically apply fixable improvements
+ */
+export function autoFix(spec, improvements, options = {}) {
+    const { applyQuickWinsOnly = false, maxPriority = 'low', skipManual = true } = options;
+    const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+    const maxPriorityLevel = priorityOrder[maxPriority] ?? 3;
+    const appliedFixes = [];
+    const skippedFixes = [];
+    const fixedSections = spec.sections.map(section => {
+        const sectionImprovements = improvements.filter(imp => imp.sectionName === section.name);
+        let currentInstruction = section.instruction;
+        let modified = false;
+        // Sort improvements by priority for this section
+        const sortedImps = [...sectionImprovements].sort((a, b) => (priorityOrder[a.priority] ?? 3) - (priorityOrder[b.priority] ?? 3));
+        for (const improvement of sortedImps) {
+            // Check if should apply
+            if ((priorityOrder[improvement.priority] ?? 3) > maxPriorityLevel)
+                continue;
+            if (applyQuickWinsOnly && improvement.effort !== 'trivial' && improvement.effort !== 'easy')
+                continue;
+            if (!improvement.autoFixable) {
+                skippedFixes.push({
+                    sectionName: section.name,
+                    reason: 'Requires manual review',
+                    manualActionNeeded: improvement.suggestion
+                });
+                continue;
+            }
+            // Apply fix (only the first one for simplicity, or could chain)
+            // For now, we chain them by using the 'after' of the previous as 'before' of the next
+            // But 'before' in improvement object is relative to the ORIGINAL state.
+            // So we just apply the one with the highest priority for the section.
+            appliedFixes.push({
+                sectionName: section.name,
+                improvement: improvement.issue,
+                before: currentInstruction || '',
+                after: improvement.after
+            });
+            currentInstruction = improvement.after;
+            modified = true;
+            break; // Only apply one fix per section in this pass to avoid conflicts
+        }
+        return modified ? { ...section, instruction: currentInstruction } : section;
+    });
+    const summary = `Applied ${appliedFixes.length} fixes, skipped ${skippedFixes.length}`;
+    return {
+        fixed: {
+            ...spec,
+            sections: fixedSections
+        },
+        appliedFixes,
+        skippedFixes,
+        summary
+    };
+}

package/dist/tokens/cognitive-cost.d.ts

@@ -0,0 +1,10 @@
+import type { CognitiveCost, LevelCostComparison } from './types.js';
+import type { OutputFormatSpec } from '../types.js';
+/**
+ * Calculate cognitive cost of creating/maintaining spec
+ */
+export declare function calculateCognitiveCost(spec: OutputFormatSpec): CognitiveCost;
+/**
+ * Compare cognitive cost across different compliance levels
+ */
+export declare function compareLevelCosts(spec: OutputFormatSpec): LevelCostComparison;

package/dist/tokens/cognitive-cost.js

@@ -0,0 +1,205 @@
+import { parseSystemPart } from './parser.js';
+import { detectSystemPartLevel } from './compliance.js';
+/**
+ * Calculate cognitive cost of creating/maintaining spec
+ */
+export function calculateCognitiveCost(spec) {
+    const perSection = [];
+    let totalCost = 0;
+    let complexityCost = 0;
+    let decisionCost = 0;
+    for (const section of spec.sections) {
+        const sectionCost = calculateSectionCost(section);
+        perSection.push(sectionCost);
+        totalCost += sectionCost.cost;
+        // Track breakdown
+        complexityCost += getComplexityCost(section.kind || 'text');
+        decisionCost += getDecisionCost(sectionCost.level);
+    }
+    const baseCost = spec.sections.length * 1; // Base effort per section
+    return {
+        totalCost: Math.min(100, totalCost),
+        perSection,
+        breakdown: {
+            baseCost,
+            complexityCost,
+            decisionCost,
+            totalSections: spec.sections.length
+        },
+        recommendation: generateCostRecommendation(totalCost, spec.sections.length)
+    };
+}
+/**
+ * Calculate cost for individual section
+ */
+function calculateSectionCost(section) {
+    const kind = section.kind || 'text';
+    const systemPart = parseSystemPart(section.instruction, kind);
+    const level = systemPart ? detectSystemPartLevel(systemPart, kind) : null;
+    const factors = [];
+    let cost = 0;
+    // Base cost by level
+    const levelCosts = { 0: 0, 1: 1, 2: 3, 3: 5 };
+    const levelCost = levelCosts[level || 0];
+    cost += levelCost;
+    if (level !== null && level > 0) {
+        factors.push({
+            factor: 'system_part_level',
+            impact: levelCost,
+            description: `L${level} requires ${getLevelEffortDescription(level)}`
+        });
+    }
+    // Complexity by section kind
+    const kindCost = getComplexityCost(kind);
+    cost += kindCost;
+    if (kindCost > 0) {
+        factors.push({
+            factor: 'section_complexity',
+            impact: kindCost,
+            description: getKindComplexityDescription(kind)
+        });
+    }
+    // Additional cost for specific patterns
+    if (systemPart) {
+        const patternCost = getPatternCost(systemPart);
+        cost += patternCost.cost;
+        if (patternCost.cost > 0) {
+            factors.push({
+                factor: 'pattern_complexity',
+                impact: patternCost.cost,
+                description: patternCost.description
+            });
+        }
+    }
+    return {
+        sectionName: section.name,
+        cost,
+        level,
+        factors
+    };
+}
+function getLevelEffortDescription(level) {
+    const descriptions = {
+        0: 'no thinking',
+        1: 'picking from 4 simple options',
+        2: 'thinking about ranges',
+        3: 'considering minimums and approximations'
+    };
+    return descriptions[level];
+}
+function getComplexityCost(kind) {
+    const costs = {
+        'text': 0, // Simplest
+        'list': 1,
+        'ordered_list': 1,
+        'code': 1,
+        'table': 2, // Most complex (2 dimensions)
+        'ordered_table': 2
+    };
+    return costs[kind] || 0;
+}
+function getKindComplexityDescription(kind) {
+    const descriptions = {
+        'text': 'Simple single value',
+        'list': 'Need to estimate item count',
+        'ordered_list': 'Need to estimate item count',
+        'code': 'Need to estimate line count',
+        'table': 'Need to think about rows AND columns',
+        'ordered_table': 'Need to think about rows AND columns'
+    };
+    return descriptions[kind] || '';
+}
+function getDecisionCost(level) {
+    if (level === null)
+        return 0;
+    const costs = { 0: 0, 1: 0.5, 2: 1.5, 3: 2.5 };
+    return costs[level];
+}
+function getPatternCost(systemPart) {
+    const { parsed } = systemPart;
+    switch (parsed.type) {
+        case 'items':
+        case 'lines':
+            if (parsed.atLeast) {
+                return { cost: 1, description: 'Deciding "at least" minimum requires judgment' };
+            }
+            if (parsed.max !== null) {
+                return { cost: 0.5, description: 'Ranges require estimating both min and max' };
+            }
+            return { cost: 0, description: '' };
+        case 'table':
+            let tableCost = 0;
+            let desc = [];
+            if (parsed.rows.atLeast || parsed.columns.atLeast) {
+                tableCost += 1;
+                desc.push('minimums require judgment');
+            }
+            if (parsed.rows.max !== null || parsed.columns.max !== null) {
+                tableCost += 0.5;
+                desc.push('ranges require estimation');
+            }
+            return {
+                cost: tableCost,
+                description: desc.length > 0 ? `Two dimensions: ${desc.join(', ')}` : ''
+            };
+        default:
+            return { cost: 0, description: '' };
+    }
+}
+function generateCostRecommendation(totalCost, sectionCount) {
+    if (sectionCount === 0)
+        return 'Empty spec';
+    const avgCost = totalCost / sectionCount;
+    if (avgCost < 2) {
+        return 'Low cognitive load - easy to write and maintain';
+    }
+    else if (avgCost < 4) {
+        return 'Moderate cognitive load - reasonable effort required';
+    }
+    else if (avgCost < 6) {
+        return 'High cognitive load - consider simplifying some sections';
+    }
+    else {
+        return 'Very high cognitive load - strongly consider reducing to L2 or L1 for some sections';
+    }
+}
+/**
+ * Compare cognitive cost across different compliance levels
+ */
+export function compareLevelCosts(spec) {
+    const costs = { 0: 0, 1: 0, 2: 0, 3: 0 };
+    // Simulate cost at each level
+    for (let level = 0; level <= 3; level++) {
+        costs[level] = estimateCostAtLevel(spec, level);
+    }
+    return {
+        byLevel: costs,
+        recommendation: getBestLevelForCost(costs)
+    };
+}
+function estimateCostAtLevel(spec, level) {
+    const levelBaseCosts = { 0: 0, 1: 1, 2: 3, 3: 5 };
+    const baseCost = levelBaseCosts[level];
+    let total = spec.sections.length * baseCost;
+    // Add complexity cost
+    for (const section of spec.sections) {
+        total += getComplexityCost(section.kind || 'text');
+        total += getDecisionCost(level);
+    }
+    return total;
+}
+function getBestLevelForCost(costs) {
+    // L2 is usually the sweet spot
+    if (costs[2] < 50) {
+        return 'L2 recommended - good balance of precision and effort';
+    }
+    else if (costs[1] < 30) {
+        return 'L1 recommended - keep it simple for this spec';
+    }
+    else if (costs[3] < 70) {
+        return 'L3 acceptable - complexity is manageable';
+    }
+    else {
+        return 'Consider reducing spec size or using L1/L2';
+    }
+}

package/dist/tokens/compliance.d.ts

@@ -0,0 +1,10 @@
+import type { ComplianceLevel, ComplianceReport, SystemPart } from './types.js';
+import type { OutputFormatSpec, SectionKind } from '../types.js';
+/**
+ * Detect the compliance level of a system part
+ */
+export declare function detectSystemPartLevel(systemPart: SystemPart, kind: SectionKind | 'code'): ComplianceLevel;
+/**
+ * Check if a spec complies with a target level
+ */
+export declare function checkSpecCompliance(spec: OutputFormatSpec, targetLevel?: ComplianceLevel): ComplianceReport;