flex-md 4.7.2 → 4.7.3

package/dist-cjs/tokens/index.cjs

@@ -0,0 +1,74 @@
+"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.getMaxTokens = getMaxTokens;
+exports.getMaxTokensFromInstructions = getMaxTokensFromInstructions;
+const parser_js_1 = require("../ofs/parser.cjs");
+const spec_estimator_js_1 = require("./spec-estimator.cjs");
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./parser.cjs"), exports);
+__exportStar(require("./estimator.cjs"), exports);
+__exportStar(require("./spec-estimator.cjs"), exports);
+__exportStar(require("./runtime-estimator.cjs"), exports);
+__exportStar(require("./validator.cjs"), exports);
+__exportStar(require("./compliance.cjs"), exports);
+__exportStar(require("./cognitive-cost.cjs"), exports);
+__exportStar(require("./confidence.cjs"), exports);
+__exportStar(require("./smart-report.cjs"), exports);
+__exportStar(require("./improvements.cjs"), exports);
+__exportStar(require("./auto-fix.cjs"), exports);
+/**
+ * Convenience function: estimate max_tokens from spec
+ *
+ * @param spec - OutputFormatSpec object, markdown string, or full instructions text
+ * @param options - Estimation options
+ * @returns Estimated max_tokens value
+ */
+function getMaxTokens(spec, options) {
+    if (!spec)
+        return 0;
+    const extractFromInstructions = options?.extractFromInstructions ?? false;
+    // If extractFromInstructions is true and spec is a string, try to extract both formats
+    if (extractFromInstructions && typeof spec === 'string') {
+        const formatSpecs = (0, parser_js_1.parseFormatSpecs)(spec);
+        if (formatSpecs.input || formatSpecs.output) {
+            const estimate = (0, spec_estimator_js_1.estimateFormatSpecsTokens)(formatSpecs.input, formatSpecs.output, options);
+            return estimate.total.estimated;
+        }
+        // Fall through to output-only parsing if no formats found
+    }
+    // Original behavior: parse as output format spec
+    const parsedSpec = typeof spec === 'string'
+        ? (0, parser_js_1.parseOutputFormatSpec)(spec)
+        : spec;
+    if (!parsedSpec)
+        return 0;
+    const estimate = (0, spec_estimator_js_1.estimateSpecTokens)(parsedSpec, options);
+    return estimate.total.estimated;
+}
+/**
+ * Estimate max tokens from entire instructions text.
+ * Automatically extracts both input and output format specs if present.
+ *
+ * @param instructions - Full instructions text that may contain format specs
+ * @param options - Estimation options
+ * @returns Estimated max_tokens value based on both input and output formats
+ */
+function getMaxTokensFromInstructions(instructions, options) {
+    const formatSpecs = (0, parser_js_1.parseFormatSpecs)(instructions);
+    const estimate = (0, spec_estimator_js_1.estimateFormatSpecsTokens)(formatSpecs.input, formatSpecs.output, options);
+    return estimate.total.estimated;
+}

package/dist-cjs/tokens/parser.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSystemPart = parseSystemPart;
+const patterns_js_1 = require("./patterns.cjs");
+function parseSystemPart(instruction, kind // Allow 'code' as a special case if needed
+) {
+    if (!instruction)
+        return null;
+    const pattern = patterns_js_1.SYSTEM_PART_PATTERNS[kind];
+    if (!pattern)
+        return null;
+    const match = instruction.match(pattern);
+    if (!match)
+        return null;
+    // Split into system and guidance parts
+    const parts = instruction.split(patterns_js_1.INSTRUCTION_SPLIT);
+    const raw = parts[0];
+    const guidance = parts.slice(1).join('. ') || null;
+    const parsed = parseMatchByKind(kind, match);
+    if (!parsed)
+        return null;
+    return { raw, guidance, parsed };
+}
+function parseMatchByKind(kind, match) {
+    switch (kind) {
+        case 'text':
+            return parseTextMatch(match);
+        case 'list':
+        case 'ordered_list':
+            return parseItemsMatch(match);
+        case 'table':
+        case 'ordered_table':
+            return parseTableMatch(match);
+        case 'code':
+            return parseCodeMatch(match);
+        default:
+            return null;
+    }
+}
+function parseTextMatch(match) {
+    const raw = match[1].toLowerCase().replace(/\s+/g, ' ');
+    // Map to canonical LengthValue
+    const lengthMap = {
+        '1 sentence': '1 sentence',
+        '1-2 sentences': '1-2 sentences',
+        '1 paragraph': '1 paragraph',
+        '2-3 paragraphs': '2-3 paragraphs',
+        'brief': 'brief',
+        'moderate': 'moderate',
+        'detailed': 'detailed',
+        'extensive': 'extensive'
+    };
+    const value = lengthMap[raw] || 'moderate';
+    return { type: 'length', value };
+}
+function parseItemsMatch(match) {
+    // match[1] = "at least" (optional)
+    // match[2] = min number
+    // match[3] = max number (optional)
+    return {
+        type: 'items',
+        min: parseInt(match[2]),
+        max: match[3] ? parseInt(match[3]) : null,
+        atLeast: !!match[1]
+    };
+}
+function parseTableMatch(match) {
+    // match[1] = rows "at least" (optional)
+    // match[2] = rows min
+    // match[3] = rows max (optional)
+    // match[4] = columns "at least" (optional)
+    // match[5] = columns min
+    // match[6] = columns max (optional)
+    return {
+        type: 'table',
+        rows: {
+            min: parseInt(match[2]),
+            max: match[3] ? parseInt(match[3]) : null,
+            atLeast: !!match[1],
+            approximate: false
+        },
+        columns: {
+            min: parseInt(match[5]),
+            max: match[6] ? parseInt(match[6]) : null,
+            atLeast: !!match[4],
+            approximate: false
+        }
+    };
+}
+function parseCodeMatch(match) {
+    // match[1] = "~" (optional)
+    // match[2] = min number
+    // match[3] = max number (optional)
+    return {
+        type: 'lines',
+        min: parseInt(match[2]),
+        max: match[3] ? parseInt(match[3]) : null,
+        approximate: !!match[1]
+    };
+}

package/dist-cjs/tokens/patterns.cjs

@@ -0,0 +1,23 @@
+"use strict";
+// patterns.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTION_SPLIT = exports.SYSTEM_PART_PATTERNS = void 0;
+exports.SYSTEM_PART_PATTERNS = {
+    // TEXT: Enumerated literal strings only
+    text: /^Length:\s*(1\s+sentence|1-2\s+sentences|1\s+paragraph|2-3\s+paragraphs|brief|moderate|detailed|extensive)/i,
+    // LIST/ORDERED-LIST: [optional "at least"] + number + [optional range]
+    // Matches: "3" | "3-5" | "at least 3"
+    list: /^Items:\s*(?:(at least)\s+)?(\d+)(?:-(\d+))?/i,
+    ordered_list: /^Items:\s*(?:(at least)\s+)?(\d+)(?:-(\d+))?/i,
+    // TABLE: Two numeric patterns (rows and columns)
+    // Matches: "Rows: 3, Columns: 5" | "Rows: 3-5, Columns: at least 2"
+    table: /^Rows:\s*(?:(at least)\s+)?(\d+)(?:-(\d+))?,\s*Columns:\s*(?:(at least)\s+)?(\d+)(?:-(\d+))?/i,
+    ordered_table: /^Rows:\s*(?:(at least)\s+)?(\d+)(?:-(\d+))?,\s*Columns:\s*(?:(at least)\s+)?(\d+)(?:-(\d+))?/i,
+    // CODE: [optional "~"] + number + [optional range]
+    // Matches: "10" | "10-20" | "~50"
+    // Note: SectionKind doesn't include 'code' currently, but we might handle it if it's added.
+    // For now, let's keep it but expect SectionKind to match.
+    code: /^Lines:\s*(~)?(\d+)(?:-(\d+))?/i
+};
+// Separator for splitting system part from guidance
+exports.INSTRUCTION_SPLIT = /\.\s+/;

package/dist-cjs/tokens/runtime-estimator.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeEstimateTokens = runtimeEstimateTokens;
+const parser_js_1 = require("../ofs/parser.cjs");
+const spec_estimator_js_1 = require("./spec-estimator.cjs");
+const estimator_js_1 = require("./estimator.cjs");
+/**
+ * Estimate max_tokens for an LLM API call at runtime.
+ *
+ * This function estimates the total tokens needed by considering:
+ * - The prompt text (user input)
+ * - Context (previous messages, system messages, etc.)
+ * - Instructions (which may contain output format specs)
+ * - Expected output format (extracted from instructions)
+ *
+ * Note: Input format specs in instructions are ignored (they're for planning/design only).
+ * Only output format specs are used for runtime token estimation.
+ *
+ * @param params - Runtime estimation parameters
+ * @returns Token estimate with breakdown
+ */
+function runtimeEstimateTokens(params) {
+    const { prompt = '', context = '', instructions = '' } = params;
+    const opts = {
+        includeOptional: params.options?.includeOptional ?? true,
+        safetyMultiplier: params.options?.safetyMultiplier ?? 1.2,
+        strategy: params.options?.strategy ?? 'average',
+        estimatePrompt: params.options?.estimatePrompt ?? true,
+        estimateContext: params.options?.estimateContext ?? true,
+        estimateInstructions: params.options?.estimateInstructions ?? true,
+        additionalOverhead: params.options?.additionalOverhead ?? 0
+    };
+    // Extract format specs from instructions (only output format is used at runtime)
+    const formatSpecs = (0, parser_js_1.parseFormatSpecs)(instructions);
+    // Estimate tokens for each component
+    const promptTokens = opts.estimatePrompt ? (0, estimator_js_1.estimateTextTokens)(prompt) : 0;
+    const contextTokens = opts.estimateContext ? (0, estimator_js_1.estimateTextTokens)(context) : 0;
+    const instructionsTokens = opts.estimateInstructions ? (0, estimator_js_1.estimateTextTokens)(instructions) : 0;
+    // Estimate output tokens from output format spec (input format is for planning only)
+    const outputEstimate = formatSpecs.output
+        ? (0, spec_estimator_js_1.estimateFormatSpecsTokens)(undefined, formatSpecs.output, {
+            includeOptional: opts.includeOptional,
+            safetyMultiplier: 1.0, // Don't apply safety multiplier here, apply at the end
+            strategy: opts.strategy
+        })
+        : {
+            total: { estimated: 0, min: 0, max: 0, confidence: 'low' },
+            bySectionName: {},
+            overhead: 0
+        };
+    // Calculate total input tokens (prompt + context + instructions)
+    const inputTokens = promptTokens + contextTokens + instructionsTokens;
+    // Calculate total output tokens (from format spec)
+    // Note: max_tokens parameter in LLM APIs refers to OUTPUT tokens only
+    const outputTokens = outputEstimate.total.estimated;
+    // Apply safety multiplier to output tokens only (this is what max_tokens represents)
+    const maxTokens = Math.ceil(outputTokens * opts.safetyMultiplier) + opts.additionalOverhead;
+    // Total tokens for budgeting/planning (input + output)
+    const totalTokens = inputTokens + outputTokens + opts.additionalOverhead;
+    // Determine confidence based on output spec confidence
+    const confidence = outputEstimate.total.confidence;
+    return {
+        maxTokens, // This is the value to use for max_tokens API parameter (output only)
+        breakdown: {
+            prompt: promptTokens,
+            context: contextTokens,
+            instructions: instructionsTokens,
+            output: outputEstimate,
+            additionalOverhead: opts.additionalOverhead,
+            total: totalTokens // Total for budgeting (input + output)
+        },
+        confidence
+    };
+}

package/dist-cjs/tokens/smart-report.cjs

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeSpec = analyzeSpec;
+exports.formatSmartReport = formatSmartReport;
+const compliance_js_1 = require("./compliance.cjs");
+const cognitive_cost_js_1 = require("./cognitive-cost.cjs");
+const confidence_js_1 = require("./confidence.cjs");
+const spec_estimator_js_1 = require("./spec-estimator.cjs");
+/**
+ * Comprehensive smart analysis of spec
+ */
+function analyzeSpec(spec, targetLevel = 2) {
+    const compliance = (0, compliance_js_1.checkSpecCompliance)(spec, targetLevel);
+    const cognitiveCost = (0, cognitive_cost_js_1.calculateCognitiveCost)(spec);
+    const confidence = (0, confidence_js_1.calculateConfidence)(spec);
+    const tokenEstimate = (0, spec_estimator_js_1.estimateSpecTokens)(spec);
+    const recommendations = generateSmartRecommendations(compliance, cognitiveCost, confidence, tokenEstimate);
+    return {
+        spec,
+        compliance,
+        cognitiveCost,
+        confidence,
+        tokenEstimate,
+        recommendations
+    };
+}
+function generateSmartRecommendations(compliance, cost, confidence, estimate) {
+    const recs = [];
+    // High priority: Compliance issues
+    if (!compliance.compliant && compliance.violations.length > 0) {
+        recs.push({
+            priority: 'high',
+            category: 'quality',
+            message: `${compliance.violations.length} sections don't meet L${compliance.level} compliance`,
+            action: 'Add or upgrade system parts in flagged sections'
+        });
+    }
+    // High priority: Low confidence
+    if (confidence.overall < 70) {
+        recs.push({
+            priority: 'high',
+            category: 'confidence',
+            message: `Token estimation confidence is ${confidence.grade} (${confidence.overall.toFixed(0)}%)`,
+            action: confidence.recommendations[0]
+        });
+    }
+    // Medium priority: High cognitive cost
+    if (cost.totalCost > 60) {
+        recs.push({
+            priority: 'medium',
+            category: 'cost',
+            message: `Cognitive cost is high (${cost.totalCost.toFixed(0)}/100)`,
+            action: 'Consider reducing some sections to L2 or L1'
+        });
+    }
+    // Medium priority: Unreasonable token estimate
+    if (estimate.total.estimated > 4000) {
+        recs.push({
+            priority: 'medium',
+            category: 'quality',
+            message: `Estimated ${estimate.total.estimated} tokens - may be too large`,
+            action: 'Consider reducing scope or splitting into multiple prompts'
+        });
+    }
+    // Low priority: Optimization opportunities
+    if (confidence.overall >= 70 && confidence.overall < 90) {
+        recs.push({
+            priority: 'low',
+            category: 'confidence',
+            message: 'Good confidence, but can be improved',
+            action: 'Upgrade a few sections to L3 for better precision'
+        });
+    }
+    // Low priority: Cost optimization
+    if (cost.totalCost < 30 && confidence.overall > 80) {
+        recs.push({
+            priority: 'low',
+            category: 'cost',
+            message: 'Excellent balance of cost and confidence',
+            action: 'No changes needed'
+        });
+    }
+    return recs;
+}
+/**
+ * Format comprehensive smart report
+ */
+function formatSmartReport(analysis) {
+    const lines = [];
+    lines.push('╔═══════════════════════════════════════════════════╗');
+    lines.push('║         FLEX-MD SMART ANALYSIS REPORT            ║');
+    lines.push('╚═══════════════════════════════════════════════════╝');
+    lines.push('');
+    // Summary Dashboard
+    lines.push('📊 SUMMARY DASHBOARD');
+    lines.push('─'.repeat(50));
+    lines.push(`Compliance:      ${analysis.compliance.compliant ? '✓' : '✗'} L${analysis.compliance.level} ${analysis.compliance.compliant ? 'PASS' : 'FAIL'}`);
+    lines.push(`Confidence:      ${analysis.confidence.grade} (${analysis.confidence.overall.toFixed(0)}%)`);
+    lines.push(`Cognitive Cost:  ${analysis.cognitiveCost.totalCost.toFixed(0)}/100`);
+    lines.push(`Token Estimate:  ${analysis.tokenEstimate.total.estimated} tokens`);
+    lines.push('');
+    // Key Metrics
+    lines.push('📈 KEY METRICS');
+    lines.push('─'.repeat(50));
+    lines.push(`Total Sections:              ${analysis.spec.sections.length}`);
+    lines.push(`With System Parts:           ${analysis.compliance.summary.compliantSections}`);
+    lines.push(`Coverage:                    ${analysis.confidence.bySection.filter(s => s.hasSystemPart).length}/${analysis.spec.sections.length} (${((analysis.confidence.bySection.filter(s => s.hasSystemPart).length / (analysis.spec.sections.length || 1)) * 100).toFixed(0)}%)`);
+    lines.push(`Average Compliance Level:    L${(analysis.compliance.summary.averageLevel || 0).toFixed(1)}`);
+    lines.push('');
+    // Recommendations
+    if (analysis.recommendations.length > 0) {
+        lines.push('💡 RECOMMENDATIONS');
+        lines.push('─'.repeat(50));
+        const highPriority = analysis.recommendations.filter(r => r.priority === 'high');
+        const mediumPriority = analysis.recommendations.filter(r => r.priority === 'medium');
+        const lowPriority = analysis.recommendations.filter(r => r.priority === 'low');
+        if (highPriority.length > 0) {
+            lines.push('🔴 High Priority:');
+            highPriority.forEach(r => {
+                lines.push(`   • ${r.message}`);
+                if (r.action)
+                    lines.push(`     → ${r.action}`);
+            });
+            lines.push('');
+        }
+        if (mediumPriority.length > 0) {
+            lines.push('🟡 Medium Priority:');
+            mediumPriority.forEach(r => {
+                lines.push(`   • ${r.message}`);
+                if (r.action)
+                    lines.push(`     → ${r.action}`);
+            });
+            lines.push('');
+        }
+        if (lowPriority.length > 0) {
+            lines.push('🟢 Low Priority:');
+            lowPriority.forEach(r => {
+                lines.push(`   • ${r.message}`);
+                if (r.action)
+                    lines.push(`     → ${r.action}`);
+            });
+            lines.push('');
+        }
+    }
+    // Section Breakdown
+    lines.push('📋 SECTION BREAKDOWN');
+    lines.push('─'.repeat(50));
+    lines.push('Section                    Level  Confidence  Cost  Tokens');
+    lines.push('─'.repeat(50));
+    analysis.confidence.bySection.forEach((conf, i) => {
+        const cost = analysis.cognitiveCost.perSection[i];
+        const tokens = analysis.tokenEstimate.bySectionName[conf.sectionName];
+        const level = conf.level !== null ? `L${conf.level}` : 'L0';
+        const confStr = `${conf.confidence.toFixed(0)}%`;
+        const costStr = cost ? `${cost.cost.toFixed(1)}` : '0.0';
+        const tokenStr = tokens ? `~${tokens.estimated}` : 'N/A';
+        const name = conf.sectionName.length > 24 ? conf.sectionName.slice(0, 21) + '...' : conf.sectionName.padEnd(24);
+        lines.push(`${name}  ${level.padEnd(5)}  ${confStr.padEnd(10)}  ${costStr.padEnd(4)}  ${tokenStr}`);
+    });
+    lines.push('');
+    // Confidence Factors
+    if (analysis.confidence.factors.length > 0) {
+        lines.push('🎯 CONFIDENCE FACTORS');
+        lines.push('─'.repeat(50));
+        analysis.confidence.factors.forEach(factor => {
+            const icon = factor.impact === 'positive' ? '✓' : factor.impact === 'negative' ? '✗' : '○';
+            const sign = factor.score >= 0 ? '+' : '';
+            lines.push(`${icon} ${factor.factor}: ${sign}${factor.score}`);
+            lines.push(`   ${factor.description}`);
+        });
+        lines.push('');
+    }
+    // Cost Breakdown
+    lines.push('💰 COGNITIVE COST BREAKDOWN');
+    lines.push('─'.repeat(50));
+    lines.push(`Base Cost:        ${analysis.cognitiveCost.breakdown.baseCost.toFixed(1)}`);
+    lines.push(`Complexity Cost:  ${analysis.cognitiveCost.breakdown.complexityCost.toFixed(1)}`);
+    lines.push(`Decision Cost:    ${analysis.cognitiveCost.breakdown.decisionCost.toFixed(1)}`);
+    lines.push(`Total Cost:       ${analysis.cognitiveCost.totalCost.toFixed(1)}/100`);
+    lines.push(`Assessment:       ${analysis.cognitiveCost.recommendation}`);
+    lines.push('');
+    // Token Estimate
+    lines.push('🔢 TOKEN ESTIMATE');
+    lines.push('─'.repeat(50));
+    lines.push(`Estimated:  ${analysis.tokenEstimate.total.estimated} tokens`);
+    lines.push(`Range:      ${analysis.tokenEstimate.total.min} - ${analysis.tokenEstimate.total.max} tokens`);
+    lines.push(`Overhead:   ${analysis.tokenEstimate.overhead} tokens`);
+    lines.push(`Confidence: ${analysis.confidence.grade}`);
+    lines.push('');
+    return lines.join('\n');
+}

package/dist-cjs/tokens/spec-estimator.cjs

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateSpecTokens = estimateSpecTokens;
+exports.estimateInputSpecTokens = estimateInputSpecTokens;
+exports.estimateFormatSpecsTokens = estimateFormatSpecsTokens;
+const parser_js_1 = require("./parser.cjs");
+const estimator_js_1 = require("./estimator.cjs");
+function estimateSpecTokens(spec, options = {}) {
+    const { includeOptional = true, safetyMultiplier = 1.2, strategy = 'average' } = options;
+    const bySectionName = {};
+    let totalEstimated = 0;
+    let totalMin = 0;
+    let totalMax = 0;
+    for (const section of spec.sections) {
+        // Skip optional sections if requested
+        const isRequired = section.required !== false; // Default to required if not explicitly false
+        if (!includeOptional && !isRequired)
+            continue;
+        const kind = section.kind || 'text';
+        const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+        let estimate;
+        if (systemPart) {
+            estimate = (0, estimator_js_1.estimateTokens)(systemPart);
+        }
+        else {
+            estimate = (0, estimator_js_1.getFallbackEstimate)(kind, isRequired);
+        }
+        // Apply optional section discount
+        if (!isRequired) {
+            estimate = {
+                estimated: Math.round(estimate.estimated * 0.6),
+                min: Math.round(estimate.min * 0.5),
+                max: Math.round(estimate.max * 0.7),
+                confidence: 'low'
+            };
+        }
+        bySectionName[section.name] = estimate;
+        totalEstimated += estimate.estimated;
+        totalMin += estimate.min;
+        totalMax += estimate.max;
+    }
+    // Add overhead
+    const overhead = estimator_js_1.TOKEN_CONSTANTS.baseOverhead +
+        (spec.sections.length * estimator_js_1.TOKEN_CONSTANTS.headingOverhead);
+    totalEstimated += overhead;
+    totalMin += overhead;
+    totalMax += overhead;
+    // Apply strategy
+    let finalEstimate;
+    switch (strategy) {
+        case 'conservative':
+            finalEstimate = totalMin;
+            break;
+        case 'generous':
+            finalEstimate = totalMax;
+            break;
+        case 'average':
+        default:
+            finalEstimate = totalEstimated;
+    }
+    // Apply safety multiplier
+    finalEstimate = Math.ceil(finalEstimate * safetyMultiplier);
+    return {
+        total: {
+            estimated: finalEstimate,
+            min: Math.ceil(totalMin * safetyMultiplier),
+            max: Math.ceil(totalMax * safetyMultiplier),
+            confidence: 'medium'
+        },
+        bySectionName,
+        overhead
+    };
+}
+/**
+ * Estimate tokens for an Input Format Spec.
+ * Uses the same logic as output format estimation.
+ */
+function estimateInputSpecTokens(spec, options = {}) {
+    // Input format uses the same structure as output format, so reuse the same logic
+    const outputSpec = {
+        ...spec,
+        descriptorType: "output_format_spec"
+    };
+    return estimateSpecTokens(outputSpec, options);
+}
+/**
+ * Estimate tokens for both input and output format specs.
+ * Combines estimates from both if present.
+ */
+function estimateFormatSpecsTokens(inputSpec, outputSpec, options = {}) {
+    const inputEstimate = inputSpec ? estimateInputSpecTokens(inputSpec, options) : null;
+    const outputEstimate = outputSpec ? estimateSpecTokens(outputSpec, options) : null;
+    // If only one is present, return it
+    if (!inputEstimate && outputEstimate)
+        return outputEstimate;
+    if (inputEstimate && !outputEstimate)
+        return inputEstimate;
+    if (!inputEstimate && !outputEstimate) {
+        // Return empty estimate
+        return {
+            total: { estimated: 0, min: 0, max: 0, confidence: 'low' },
+            bySectionName: {},
+            overhead: 0
+        };
+    }
+    // Combine both estimates
+    const combined = {
+        total: {
+            estimated: inputEstimate.total.estimated + outputEstimate.total.estimated,
+            min: inputEstimate.total.min + outputEstimate.total.min,
+            max: inputEstimate.total.max + outputEstimate.total.max,
+            confidence: inputEstimate.total.confidence === 'high' && outputEstimate.total.confidence === 'high'
+                ? 'high'
+                : inputEstimate.total.confidence === 'low' || outputEstimate.total.confidence === 'low'
+                    ? 'low'
+                    : 'medium'
+        },
+        bySectionName: {
+            ...Object.fromEntries(Object.entries(inputEstimate.bySectionName).map(([k, v]) => [`input:${k}`, v])),
+            ...Object.fromEntries(Object.entries(outputEstimate.bySectionName).map(([k, v]) => [`output:${k}`, v]))
+        },
+        overhead: inputEstimate.overhead + outputEstimate.overhead
+    };
+    return combined;
+}

package/dist-cjs/tokens/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/tokens/validator.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSystemParts = validateSystemParts;
+const parser_js_1 = require("./parser.cjs");
+function validateSystemParts(spec) {
+    const errors = [];
+    const warnings = [];
+    for (const section of spec.sections) {
+        const isRequired = section.required !== false;
+        const kind = section.kind || 'text';
+        if (!section.instruction) {
+            if (isRequired) {
+                warnings.push({
+                    sectionName: section.name,
+                    message: 'Required section has no instruction. Token estimation will use fallback.'
+                });
+            }
+            continue;
+        }
+        const systemPart = (0, parser_js_1.parseSystemPart)(section.instruction, kind);
+        if (!systemPart) {
+            warnings.push({
+                sectionName: section.name,
+                message: `No valid system part found. Expected pattern for '${kind}' kind.`
+            });
+            continue;
+        }
+        // Validate ranges
+        if (systemPart.parsed.type === 'items' || systemPart.parsed.type === 'lines') {
+            const { min, max } = systemPart.parsed;
+            if (max !== null && max < min) {
+                errors.push({
+                    sectionName: section.name,
+                    message: `Invalid range: max (${max}) is less than min (${min})`,
+                    instruction: section.instruction
+                });
+            }
+        }
+        if (systemPart.parsed.type === 'table') {
+            const { rows, columns } = systemPart.parsed;
+            if (rows.max !== null && rows.max < rows.min) {
+                errors.push({
+                    sectionName: section.name,
+                    message: `Invalid rows range: max (${rows.max}) < min (${rows.min})`,
+                    instruction: section.instruction
+                });
+            }
+            if (columns.max !== null && columns.max < columns.min) {
+                errors.push({
+                    sectionName: section.name,
+                    message: `Invalid columns range: max (${columns.max}) < min (${columns.min})`,
+                    instruction: section.instruction
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings
+    };
+}

package/dist-cjs/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });