flex-md 4.7.2 → 4.7.4

package/dist-cjs/strictness/processor.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResponseMarkdown = processResponseMarkdown;
+const validate_js_1 = require("../validate/validate.cjs");
+const extract_js_1 = require("../extract/extract.cjs");
+const issuesEnvelope_js_1 = require("../ofs/issuesEnvelope.cjs");
+/**
+ * Unified entry point for processing a response against an OFS.
+ */
+function processResponseMarkdown(text, spec, strict // StrictnessOptions
+) {
+    const level = strict.level ?? 0;
+    const validation = (0, validate_js_1.validateMarkdownAgainstOfs)(text, spec, level, strict.policy);
+    const result = {
+        ok: validation.ok,
+        strictness: strict,
+        usedContainer: validation.stats?.container.fenceCount === 1,
+        innerMarkdown: text, // Simplified: ideally strip container here
+        validation,
+        issues: validation.issues,
+    };
+    if (validation.ok) {
+        result.extracted = (0, extract_js_1.extractFromMarkdown)(text, spec);
+    }
+    else {
+        const issuesEnv = (0, issuesEnvelope_js_1.parseIssuesEnvelope)(text);
+        if (issuesEnv.isIssuesEnvelope) {
+            result.issuesEnvelope = issuesEnv;
+        }
+    }
+    return result;
+}

package/dist-cjs/strictness/types.cjs

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strictnessDefaults = strictnessDefaults;
+function strictnessDefaults(level) {
+    const common = {
+        tablesGuidance: "auto",
+        listsGuidance: "auto",
+        emptyNoneGuidance: "auto",
+        containerGuidance: "auto",
+        typedJsonGuidance: "auto",
+        acceptAnyHeadingLevel: true,
+        duplicateSectionStrategy: "merge",
+    };
+    if (level === 0) {
+        return {
+            ...common,
+            level,
+            container: "none",
+            requireOfs: false,
+            requireAllSections: false,
+            policy: {
+                outsideContainer: "ignore",
+                missingContainer: "ignore",
+                multipleContainers: "ignore",
+                missingRequiredSection: "warn",
+                missingOptionalSection: "ignore",
+                wrongSectionKindRequired: "warn",
+                wrongSectionKindOptional: "ignore",
+                emptySectionWithoutNoneRequired: "warn",
+                emptySectionWithoutNoneOptional: "ignore",
+                missingRequiredTable: "warn",
+                missingOptionalTable: "ignore",
+                orderedTableViolationsRequired: "warn",
+                orderedTableViolationsOptional: "ignore",
+            }
+        };
+    }
+    if (level === 1) {
+        return {
+            ...common,
+            level,
+            container: "none",
+            requireOfs: true,
+            requireAllSections: true,
+            policy: {
+                missingRequiredSection: "error",
+                missingOptionalSection: "ignore",
+                wrongSectionKindRequired: "error",
+                wrongSectionKindOptional: "warn",
+                emptySectionWithoutNoneRequired: "error",
+                emptySectionWithoutNoneOptional: "warn",
+                missingRequiredTable: "error",
+                missingOptionalTable: "ignore",
+                orderedTableViolationsRequired: "error",
+                orderedTableViolationsOptional: "warn",
+            }
+        };
+    }
+    if (level === 2) {
+        return {
+            ...common,
+            level,
+            container: "markdown_fence",
+            requireSingleContainer: true,
+            requireOfs: true,
+            requireAllSections: true,
+            policy: {
+                outsideContainer: "error",
+                missingContainer: "error",
+                multipleContainers: "error",
+                missingRequiredSection: "error",
+                missingOptionalSection: "ignore",
+                wrongSectionKindRequired: "error",
+                wrongSectionKindOptional: "warn",
+                emptySectionWithoutNoneRequired: "error",
+                emptySectionWithoutNoneOptional: "warn",
+                missingRequiredTable: "error",
+                missingOptionalTable: "ignore",
+                orderedTableViolationsRequired: "error",
+                orderedTableViolationsOptional: "warn",
+            }
+        };
+    }
+    return {
+        ...common,
+        level: 3,
+        container: "markdown_fence",
+        requireSingleContainer: true,
+        requireOfs: true,
+        requireAllSections: true,
+        requireTypedJson: true,
+        policy: {
+            outsideContainer: "error",
+            missingContainer: "error",
+            multipleContainers: "error",
+            missingRequiredSection: "error",
+            missingOptionalSection: "ignore",
+            wrongSectionKindRequired: "error",
+            wrongSectionKindOptional: "warn",
+            emptySectionWithoutNoneRequired: "error",
+            emptySectionWithoutNoneOptional: "warn",
+            missingRequiredTable: "error",
+            missingOptionalTable: "ignore",
+            orderedTableViolationsRequired: "error",
+            orderedTableViolationsOptional: "warn",
+            jsonPayloadMissing: "error"
+        }
+    };
+}

package/dist-cjs/tokens/auto-fix.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoFix = autoFix;
+/**
+ * Automatically apply fixable improvements
+ */
+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-cjs/tokens/cognitive-cost.cjs

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCognitiveCost = calculateCognitiveCost;
+exports.compareLevelCosts = compareLevelCosts;
+const parser_js_1 = require("./parser.cjs");
+const compliance_js_1 = require("./compliance.cjs");
+/**
+ * Calculate cognitive cost of creating/maintaining spec
+ */
+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 = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+    const level = systemPart ? (0, compliance_js_1.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
+ */
+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-cjs/tokens/compliance.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSystemPartLevel = detectSystemPartLevel;
+exports.checkSpecCompliance = checkSpecCompliance;
+const parser_js_1 = require("./parser.cjs");
+/**
+ * Detect the compliance level of a system part
+ */
+function detectSystemPartLevel(systemPart, kind) {
+    const { parsed } = systemPart;
+    switch (parsed.type) {
+        case 'length':
+            // Ranges in lengths are L2
+            if (['1-2 sentences', '2-3 paragraphs'].includes(parsed.value)) {
+                return 2;
+            }
+            return 1;
+        case 'items':
+        case 'lines':
+            if (parsed.atLeast || parsed.approximate)
+                return 3;
+            if (parsed.max !== null)
+                return 2;
+            return 1;
+        case 'table':
+            if (parsed.rows.atLeast || parsed.columns.atLeast)
+                return 3;
+            if (parsed.rows.max !== null || parsed.columns.max !== null)
+                return 2;
+            return 1;
+        default:
+            return 0;
+    }
+}
+/**
+ * Check if a spec complies with a target level
+ */
+function checkSpecCompliance(spec, targetLevel = 2) {
+    const violations = [];
+    let totalLevel = 0;
+    let compliantCount = 0;
+    for (const section of spec.sections) {
+        const kind = section.kind || 'text';
+        const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+        const level = systemPart ? detectSystemPartLevel(systemPart, kind) : 0;
+        totalLevel += level;
+        if (level >= targetLevel) {
+            compliantCount++;
+        }
+        else if (section.required !== false) {
+            violations.push({
+                sectionName: section.name,
+                kind,
+                level,
+                message: `Section '${section.name}' is at L${level}, but target is L${targetLevel}`
+            });
+        }
+        else {
+            // Optional sections don't cause violations but we still count them if they are compliant
+            if (level >= targetLevel)
+                compliantCount++;
+        }
+    }
+    return {
+        compliant: violations.length === 0,
+        level: targetLevel,
+        violations,
+        summary: {
+            totalSections: spec.sections.length,
+            compliantSections: compliantCount,
+            averageLevel: spec.sections.length > 0 ? totalLevel / spec.sections.length : 0
+        }
+    };
+}