@trohde/earos 1.1.2 → 1.3.0

package/utils/export-markdown.js

@@ -0,0 +1,486 @@
+/**
+ * EaROS — Markdown export utilities for artifacts, rubrics, and evaluations.
+ *
+ * Pure client-side functions that convert structured data objects to Markdown strings.
+ */
+// ─── Shared helpers ──────────────────────────────────────────────────────────
+function humanize(key) {
+    return key.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function str(v) {
+    if (v == null)
+        return '';
+    if (typeof v === 'string')
+        return v.trim();
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return '';
+}
+function mdTable(headers, rows) {
+    if (rows.length === 0)
+        return '';
+    const sep = headers.map(() => '---');
+    const lines = [
+        `| ${headers.join(' | ')} |`,
+        `| ${sep.join(' | ')} |`,
+        ...rows.map((r) => `| ${r.map((c) => c.replace(/\|/g, '\\|').replace(/\n/g, ' ')).join(' | ')} |`),
+    ];
+    return lines.join('\n');
+}
+function mdList(items) {
+    return items.map((i) => `- ${i}`).join('\n');
+}
+function isPlainObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+export function downloadAsFile(content, filename, mimeType) {
+    if (typeof document === 'undefined')
+        return; // Node.js — no browser download
+    const blob = new Blob([content], { type: mimeType });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = filename;
+    a.click();
+    URL.revokeObjectURL(url);
+}
+// ─── Artifact Markdown ───────────────────────────────────────────────────────
+const SECTION_ORDER = [
+    'reading_guide',
+    'scope',
+    'drivers_and_principles',
+    'architecture_views',
+    'crosscutting_concerns',
+    'component_classification',
+    'components',
+    'decisions',
+    'architecture_decisions',
+    'quality_attributes',
+    'operational_model',
+    'implementation_guidance',
+    'implementation_artifacts',
+    'governance',
+    'raid',
+    'decisions_and_actions',
+    'getting_started',
+    'evolution',
+    'glossary',
+];
+function renderMetadataMd(meta) {
+    const lines = [];
+    const skip = new Set(['title', 'artifact_type']);
+    for (const [key, value] of Object.entries(meta)) {
+        if (skip.has(key))
+            continue;
+        if (value == null)
+            continue;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                continue;
+            if (isPlainObject(value[0])) {
+                lines.push(`\n**${humanize(key)}:**\n`);
+                const keys = Object.keys(value[0]);
+                lines.push(mdTable(keys.map(humanize), value.map((item) => keys.map((k) => str(item[k])))));
+            }
+            else {
+                lines.push(`**${humanize(key)}:** ${value.map(str).join(', ')}`);
+            }
+        }
+        else if (isPlainObject(value)) {
+            lines.push(`**${humanize(key)}:**`);
+            for (const [k, v] of Object.entries(value)) {
+                lines.push(`- ${humanize(k)}: ${str(v)}`);
+            }
+        }
+        else {
+            lines.push(`**${humanize(key)}:** ${str(value)}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderValueMd(value, level) {
+    const lines = [];
+    const hl = '#'.repeat(Math.min(level, 6));
+    if (typeof value === 'string') {
+        // Check for Mermaid diagram source
+        if (value.trim().startsWith('graph ') || value.trim().startsWith('flowchart ') ||
+            value.trim().startsWith('sequenceDiagram') || value.trim().startsWith('classDiagram') ||
+            value.trim().startsWith('stateDiagram') || value.trim().startsWith('erDiagram') ||
+            value.trim().startsWith('gantt') || value.trim().startsWith('pie') ||
+            value.trim().startsWith('journey') || value.trim().startsWith('C4') ||
+            value.trim().startsWith('mindmap') || value.trim().startsWith('timeline') ||
+            value.trim().startsWith('block-beta') || value.trim().startsWith('architecture-beta')) {
+            lines.push('```mermaid', value.trim(), '```');
+        }
+        else {
+            lines.push(value);
+        }
+    }
+    else if (Array.isArray(value)) {
+        if (value.length === 0)
+            return '';
+        if (typeof value[0] === 'string') {
+            lines.push(mdList(value.map(str)));
+        }
+        else if (isPlainObject(value[0])) {
+            const keys = Object.keys(value[0]);
+            lines.push(mdTable(keys.map(humanize), value.map((item) => keys.map((k) => str(item[k])))));
+        }
+    }
+    else if (isPlainObject(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            if (child == null)
+                continue;
+            if (key === 'diagram_source' || key === 'mermaid_source') {
+                lines.push('```mermaid', str(child), '```');
+            }
+            else if (typeof child === 'string') {
+                lines.push(`**${humanize(key)}:** ${child}`);
+            }
+            else if (Array.isArray(child)) {
+                if (child.length === 0)
+                    continue;
+                lines.push(`\n${hl}# ${humanize(key)}\n`);
+                lines.push(renderValueMd(child, level + 1));
+            }
+            else if (isPlainObject(child)) {
+                lines.push(`\n${hl}# ${humanize(key)}\n`);
+                lines.push(renderValueMd(child, level + 1));
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function renderSectionMd(key, value) {
+    const lines = [];
+    lines.push(`## ${humanize(key)}`);
+    lines.push('');
+    lines.push(renderValueMd(value, 3));
+    lines.push('');
+    return lines.join('\n');
+}
+export function exportArtifactToMarkdown(data) {
+    const lines = [];
+    const meta = data?.metadata ?? {};
+    const sections = data?.sections ?? {};
+    // Title
+    const title = str(meta.title) || 'Architecture Artifact';
+    const artifactType = str(data?.artifact_type ?? meta?.artifact_type ?? '');
+    lines.push(`# ${title}`);
+    if (artifactType) {
+        lines.push(`\n*${humanize(artifactType)}*`);
+    }
+    lines.push('');
+    // Metadata
+    const metaMd = renderMetadataMd(meta);
+    if (metaMd) {
+        lines.push(metaMd);
+        lines.push('\n---\n');
+    }
+    // Sections in preferred order
+    const rendered = new Set();
+    for (const key of SECTION_ORDER) {
+        if (key in sections) {
+            lines.push(renderSectionMd(key, sections[key]));
+            rendered.add(key);
+        }
+    }
+    // Unknown sections
+    for (const [key, value] of Object.entries(sections)) {
+        if (!rendered.has(key)) {
+            lines.push(renderSectionMd(key, value));
+            rendered.add(key);
+        }
+    }
+    // Top-level keys outside sections
+    const TOP_SKIP = new Set(['kind', 'artifact_type', 'metadata', 'sections']);
+    for (const [key, value] of Object.entries(data)) {
+        if (TOP_SKIP.has(key) || rendered.has(key))
+            continue;
+        lines.push(renderSectionMd(key, value));
+    }
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+}
+// ─── Rubric Markdown ─────────────────────────────────────────────────────────
+export function exportRubricToMarkdown(data) {
+    const lines = [];
+    // Title & metadata
+    const title = str(data?.title) || 'EaROS Rubric';
+    lines.push(`# ${title}`);
+    lines.push('');
+    const metaFields = [
+        ['Rubric ID', data?.rubric_id],
+        ['Version', data?.version],
+        ['Kind', data?.kind],
+        ['Status', data?.status],
+        ['Artifact Type', data?.artifact_type],
+        ['Design Method', data?.design_method],
+        ['Owner', data?.owner],
+        ['Effective Date', data?.effective_date],
+    ];
+    if (data?.inherits?.length)
+        metaFields.push(['Inherits', data.inherits.join(', ')]);
+    const validMeta = metaFields.filter(([, v]) => v != null && v !== '');
+    if (validMeta.length) {
+        lines.push(mdTable(['Field', 'Value'], validMeta.map(([k, v]) => [k, str(v)])));
+        lines.push('\n---\n');
+    }
+    // Dimensions & criteria
+    const dimensions = data?.dimensions ?? [];
+    for (const dim of dimensions) {
+        const weight = dim.weight != null ? ` (weight: ${dim.weight})` : '';
+        lines.push(`## ${str(dim.name)}${weight}`);
+        lines.push('');
+        if (dim.description)
+            lines.push(`*${str(dim.description)}*\n`);
+        const criteria = dim.criteria ?? [];
+        for (const c of criteria) {
+            lines.push(`### ${str(c.id)}: ${str(c.question)}`);
+            lines.push('');
+            if (c.description)
+                lines.push(str(c.description) + '\n');
+            // Gate
+            if (c.gate && typeof c.gate === 'object' && c.gate.enabled) {
+                lines.push(`**Gate:** ${c.gate.severity ?? 'unknown'}${c.gate.failure_effect ? ` — ${c.gate.failure_effect}` : ''}`);
+            }
+            else {
+                lines.push('**Gate:** None');
+            }
+            lines.push('');
+            // Required evidence
+            if (c.required_evidence?.length) {
+                lines.push('**Required Evidence:**\n');
+                lines.push(mdList(c.required_evidence.map(str)));
+                lines.push('');
+            }
+            // Scoring guide
+            if (c.scoring_guide) {
+                lines.push('**Scoring Guide:**\n');
+                const sgRows = Object.entries(c.scoring_guide).map(([level, desc]) => [level, str(desc)]);
+                lines.push(mdTable(['Level', 'Description'], sgRows));
+                lines.push('');
+            }
+            // Anti-patterns
+            if (c.anti_patterns?.length) {
+                lines.push('**Anti-patterns:**\n');
+                lines.push(mdList(c.anti_patterns.map(str)));
+                lines.push('');
+            }
+            // Examples
+            if (c.examples) {
+                if (c.examples.good?.length) {
+                    lines.push('**Good Examples:**\n');
+                    lines.push(mdList(c.examples.good.map(str)));
+                    lines.push('');
+                }
+                if (c.examples.bad?.length) {
+                    lines.push('**Bad Examples:**\n');
+                    lines.push(mdList(c.examples.bad.map(str)));
+                    lines.push('');
+                }
+            }
+            // Decision tree
+            if (c.decision_tree) {
+                lines.push('**Decision Tree:**\n');
+                lines.push(`> ${str(c.decision_tree).replace(/\n/g, '\n> ')}`);
+                lines.push('');
+            }
+            // Remediation hints
+            if (c.remediation_hints?.length) {
+                lines.push('**Remediation Hints:**\n');
+                lines.push(mdList(c.remediation_hints.map(str)));
+                lines.push('');
+            }
+            lines.push('---\n');
+        }
+    }
+    // Scoring section
+    if (data?.scoring) {
+        lines.push('## Scoring Model\n');
+        if (data.scoring.scale)
+            lines.push(`**Scale:** ${str(data.scoring.scale)}`);
+        if (data.scoring.method)
+            lines.push(`**Method:** ${str(data.scoring.method)}`);
+        if (data.scoring.thresholds) {
+            lines.push('\n**Thresholds:**\n');
+            for (const [k, v] of Object.entries(data.scoring.thresholds)) {
+                lines.push(`- **${humanize(k)}:** ${str(v)}`);
+            }
+        }
+        lines.push('');
+    }
+    // Outputs section
+    if (data?.outputs) {
+        lines.push('## Outputs\n');
+        for (const [k, v] of Object.entries(data.outputs)) {
+            lines.push(`- **${humanize(k)}:** ${str(v)}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+}
+function scoreEmoji(score) {
+    if (score === null || score === 'N/A')
+        return '';
+    if (score >= 3)
+        return '🟢';
+    if (score >= 2)
+        return '🟡';
+    if (score >= 1)
+        return '🟠';
+    return '🔴';
+}
+function statusLabel(status) {
+    const map = {
+        pass: 'Pass',
+        conditional_pass: 'Conditional Pass',
+        rework_required: 'Rework Required',
+        reject: 'Reject',
+        not_reviewable: 'Not Reviewable',
+        incomplete: 'Incomplete',
+    };
+    return map[status] ?? humanize(status);
+}
+export function exportEvaluationToMarkdown(meta, primaryRubricId, dimensions, results) {
+    const lines = [];
+    // Compute summary inline (same logic as computeSummary in AssessmentSummary)
+    const dimSummaries = dimensions.map((dim) => {
+        const scored = dim.criteria.filter((c) => {
+            const r = results[c.id];
+            return r && r.score !== null && r.score !== 'N/A';
+        });
+        const sum = scored.reduce((acc, c) => acc + results[c.id].score, 0);
+        const avg = scored.length > 0 ? sum / scored.length : null;
+        return { id: dim.id, name: dim.name, weight: dim.weight ?? 1.0, avgScore: avg };
+    });
+    const gateFailures = [];
+    for (const dim of dimensions) {
+        for (const c of dim.criteria) {
+            if (!c.gate || typeof c.gate !== 'object' || !c.gate.enabled)
+                continue;
+            const sev = c.gate.severity;
+            if (!sev || sev === 'none')
+                continue;
+            const r = results[c.id];
+            if (!r || r.score === null || r.score === 'N/A')
+                continue;
+            if (r.score < 2) {
+                gateFailures.push({ id: c.id, question: c.question, severity: sev, score: r.score, failure_effect: c.gate.failure_effect ?? '' });
+            }
+        }
+    }
+    const criticalFailures = gateFailures.filter((g) => g.severity === 'critical');
+    const majorFailures = gateFailures.filter((g) => g.severity === 'major');
+    const scoredDims = dimSummaries.filter((d) => d.avgScore !== null);
+    const weightedSum = scoredDims.reduce((acc, d) => acc + d.avgScore * d.weight, 0);
+    const totalWeight = scoredDims.reduce((acc, d) => acc + d.weight, 0);
+    const overallScore = scoredDims.length > 0 ? weightedSum / totalWeight : null;
+    const totalCriteria = dimensions.reduce((acc, d) => acc + d.criteria.length, 0);
+    const scoredCriteria = dimensions.reduce((acc, d) => acc + d.criteria.filter((c) => results[c.id]?.score !== null).length, 0);
+    let status = 'incomplete';
+    if (overallScore !== null) {
+        const noLowDim = dimSummaries.every((d) => d.avgScore === null || d.avgScore >= 2.0);
+        if (criticalFailures.length > 0) {
+            const hasNotReviewable = criticalFailures.some((g) => {
+                const effect = g.failure_effect.toLowerCase();
+                return effect.includes('not_reviewable') || effect.includes('not reviewable');
+            });
+            status = hasNotReviewable ? 'not_reviewable' : 'reject';
+        }
+        else if (overallScore >= 3.2 && noLowDim && majorFailures.length === 0) {
+            status = 'pass';
+        }
+        else if (overallScore >= 2.4 || majorFailures.length > 0) {
+            status = 'conditional_pass';
+        }
+        else {
+            status = 'rework_required';
+        }
+    }
+    // Title
+    lines.push('# EaROS Architecture Assessment Report');
+    lines.push('');
+    if (meta.title)
+        lines.push(`**Artifact:** ${meta.title}`);
+    if (meta.version)
+        lines.push(`**Artifact Version:** ${meta.version}`);
+    lines.push(`**Rubric:** ${primaryRubricId}`);
+    lines.push(`**Evaluation Date:** ${meta.date || new Date().toISOString().slice(0, 10)}`);
+    if (meta.author)
+        lines.push(`**Evaluator:** ${meta.author}`);
+    lines.push('');
+    lines.push('---\n');
+    // Executive Summary
+    lines.push('## Executive Summary\n');
+    lines.push(mdTable(['', ''], [
+        ['**Overall Status**', `**${statusLabel(status).toUpperCase()}**`],
+        ['**Overall Score**', overallScore !== null ? `**${overallScore.toFixed(2)} / 4.0**` : 'N/A'],
+        ['**Pass Threshold**', '3.2 / 4.0'],
+        ['**Gate Failures**', gateFailures.length > 0 ? `${gateFailures.length} (${criticalFailures.length} critical)` : 'None'],
+        ['**Criteria Scored**', `${scoredCriteria} of ${totalCriteria}`],
+    ]));
+    lines.push('\n---\n');
+    // Traffic-Light Dashboard
+    lines.push('## Traffic-Light Dashboard\n');
+    const dashRows = [];
+    for (const dim of dimensions) {
+        for (const c of dim.criteria) {
+            const r = results[c.id];
+            const score = r?.score;
+            const scoreStr = score !== null && score !== undefined ? `${score}` : '-';
+            const gateLabel = c.gate && typeof c.gate === 'object' && c.gate.enabled
+                ? ` ⚠️ ${(c.gate.severity ?? '').toUpperCase()} GATE` : '';
+            dashRows.push([
+                str(c.id) + gateLabel,
+                str(c.question),
+                scoreStr === 'N/A' ? 'N/A' : `${scoreStr} / 4`,
+                score !== null && score !== 'N/A' ? scoreEmoji(score) : '',
+            ]);
+        }
+    }
+    lines.push(mdTable(['Criterion', 'Name', 'Score', 'Status'], dashRows));
+    lines.push('\n**Legend:** 🟢 Score ≥ 3 · 🟡 Score 2–2.9 · 🟠 Score 1–1.9 · 🔴 Score 0 or gate failure\n');
+    lines.push('---\n');
+    // Dimension Summary
+    lines.push('## Dimension Summary\n');
+    const dimRows = dimSummaries.map((d) => [
+        d.id,
+        d.name,
+        d.weight.toFixed(1),
+        d.avgScore !== null ? d.avgScore.toFixed(1) : '-',
+        d.avgScore !== null ? (d.avgScore * d.weight).toFixed(1) : '-',
+    ]);
+    lines.push(mdTable(['Dimension', 'Name', 'Weight', 'Score', 'Weighted'], dimRows));
+    if (overallScore !== null) {
+        lines.push(`\n**Overall weighted score: ${overallScore.toFixed(2)} / 4.0**`);
+    }
+    lines.push('\n---\n');
+    // Gate Failures
+    if (gateFailures.length > 0) {
+        lines.push('## Gate Failures\n');
+        lines.push(mdTable(['Criterion', 'Question', 'Severity', 'Score', 'Effect'], gateFailures.map((g) => [g.id, g.question, g.severity, String(g.score), g.failure_effect || '\u2014'])));
+        lines.push('\n---\n');
+    }
+    // Per-criterion Evidence Details
+    const hasEvidence = dimensions.some((d) => d.criteria.some((c) => results[c.id]?.evidence));
+    if (hasEvidence) {
+        lines.push('## Criterion Details\n');
+        for (const dim of dimensions) {
+            for (const c of dim.criteria) {
+                const r = results[c.id];
+                if (!r || r.score === null)
+                    continue;
+                lines.push(`### ${c.id}: ${c.question}\n`);
+                lines.push(`- **Score:** ${r.score}`);
+                if (r.confidence)
+                    lines.push(`- **Confidence:** ${r.confidence}`);
+                if (r.evidence_class)
+                    lines.push(`- **Evidence Class:** ${r.evidence_class}`);
+                if (r.evidence)
+                    lines.push(`- **Evidence:** ${r.evidence}`);
+                lines.push('');
+            }
+        }
+    }
+    return lines.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+}

package/dist/assets/channel-SoktpVBQ.js

@@ -1 +0,0 @@
-import{aq as o,ar as n}from"./index-DMt1cpG6.js";const t=(r,a)=>o.lang.round(n.parse(r)[a]);export{t as c};

package/dist/assets/classDiagram-VBA2DB6C-BT2AdZTe.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-D9yxAHyd.js";import{_ as i}from"./index-DMt1cpG6.js";import"./chunk-FMBD7UC4-DoOEFFQC.js";import"./chunk-JSJVCQXG-BerphV2K.js";import"./chunk-55IACEB6-Dxqrf5oZ.js";import"./chunk-KX2RTZJC-CxUAqT05.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/assets/classDiagram-v2-RAHNMMFH-BT2AdZTe.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-D9yxAHyd.js";import{_ as i}from"./index-DMt1cpG6.js";import"./chunk-FMBD7UC4-DoOEFFQC.js";import"./chunk-JSJVCQXG-BerphV2K.js";import"./chunk-55IACEB6-Dxqrf5oZ.js";import"./chunk-KX2RTZJC-CxUAqT05.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/dist/assets/clone-DOjIfi5r.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-HuZouVIz.js";var e=4;function a(o){return r(o,e)}export{a as c};

package/dist/assets/stateDiagram-v2-FVOUBMTO-B2goOPt-.js

@@ -1 +0,0 @@
-import{s as t,b as r,a,S as s}from"./chunk-NQ4KR5QH-fCqZgFkU.js";import{_ as i}from"./index-DMt1cpG6.js";import"./chunk-55IACEB6-Dxqrf5oZ.js";import"./chunk-KX2RTZJC-CxUAqT05.js";var l={parser:a,get db(){return new s(2)},renderer:r,styles:t,init:i(e=>{e.state||(e.state={}),e.state.arrowMarkerAbsolute=e.arrowMarkerAbsolute},"init")};export{l as diagram};