@devtrack-solution/codesdd 1.2.2 → 1.2.3

package/dist/core/sdd/quality-evidence-renderer.js

@@ -0,0 +1,218 @@
+import path from 'node:path';
+import { qualityEvidenceBundleSchema, } from './quality-validation.js';
+import { SddWriteTransaction } from './write-manifest.js';
+const RUN_ID_PATTERN = /^qrun-[0-9]{8}t[0-9]{6}z-[a-z0-9-]+$/;
+export async function renderQualityEvidenceBundle(input) {
+    const parsed = qualityEvidenceBundleSchema.safeParse(input.bundle);
+    const bundle = parsed.success ? parsed.data : undefined;
+    const runId = extractRunId(bundle ?? input.bundle);
+    const reportPath = `.sdd/reports/quality-runs/${runId}/report.md`;
+    const summaryPath = `.sdd/reports/quality-runs/${runId}/summary.json`;
+    const validationIssues = parsed.success
+        ? []
+        : parsed.error.issues.map((issue) => ({
+            path: issue.path.length > 0 ? issue.path.join('.') : '<root>',
+            message: issue.message,
+        }));
+    const findings = extractFindings(bundle ?? input.bundle);
+    const runStatus = extractString(bundle ?? input.bundle, ['run', 'status']) ?? 'unknown';
+    const status = deriveRendererStatus(parsed.success, runStatus, findings);
+    const generatedAt = normalizeTimestamp(input.generatedAt);
+    const summary = {
+        schema_version: 1,
+        run_id: runId,
+        scenario_ref: extractString(bundle ?? input.bundle, ['run', 'scenario_ref']) ??
+            extractString(bundle ?? input.bundle, ['scenario', 'id']) ??
+            'unknown',
+        feature_ref: extractString(bundle ?? input.bundle, ['run', 'feature_ref']) ??
+            extractString(bundle ?? input.bundle, ['scenario', 'feature_ref']) ??
+            'unknown',
+        mode: extractString(bundle ?? input.bundle, ['run', 'mode']) ??
+            extractString(bundle ?? input.bundle, ['scenario', 'mode']) ??
+            'unknown',
+        generated_at: generatedAt,
+        warning_only: true,
+        blocking: false,
+        status,
+        run_status: runStatus,
+        validation: {
+            valid: parsed.success,
+            issue_count: validationIssues.length,
+            issues: validationIssues,
+        },
+        counts: buildCounts(bundle ?? input.bundle, findings),
+        findings,
+        outputs: {
+            report_path: reportPath,
+            summary_path: summaryPath,
+        },
+    };
+    const reportMarkdown = renderMarkdownReport(summary);
+    const tx = new SddWriteTransaction();
+    tx.writeFile(reportPath, reportMarkdown);
+    tx.writeFile(summaryPath, `${JSON.stringify(summary, null, 2)}\n`);
+    await tx.commit(input.projectRoot, input.memoryRoot ?? path.join(input.projectRoot, '.sdd'), 'quality evidence renderer');
+    return {
+        summary,
+        reportMarkdown,
+        paths: {
+            report: reportPath,
+            summary: summaryPath,
+        },
+        bundle,
+    };
+}
+function renderMarkdownReport(summary) {
+    const validationSection = summary.validation.valid
+        ? '- Schema validation: passed'
+        : [
+            '- Schema validation: warning-only issues detected',
+            '',
+            '| Path | Message |',
+            '| --- | --- |',
+            ...summary.validation.issues.map((issue) => `| ${escapeCell(issue.path)} | ${escapeCell(issue.message)} |`),
+        ].join('\n');
+    const findingsSection = summary.findings.length === 0
+        ? '- No findings recorded.'
+        : [
+            '| Severity | Code | Path | Message | Remediation |',
+            '| --- | --- | --- | --- | --- |',
+            ...summary.findings.map((finding) => [
+                `| ${escapeCell(finding.severity)}`,
+                escapeCell(finding.code),
+                escapeCell(finding.path ?? '-'),
+                escapeCell(finding.message),
+                `${escapeCell(finding.remediation)} |`,
+            ].join(' | ')),
+        ].join('\n');
+    return `# Quality Evidence Report
+
+## Summary
+- Run: \`${summary.run_id}\`
+- Scenario: \`${summary.scenario_ref}\`
+- Feature: \`${summary.feature_ref}\`
+- Mode: \`${summary.mode}\`
+- Renderer status: \`${summary.status}\`
+- Source run status: \`${summary.run_status}\`
+- Warning-only: yes
+- Blocking: no
+- Generated at: ${summary.generated_at}
+
+## Validation
+${validationSection}
+
+## Findings
+${findingsSection}
+
+## Evidence Counts
+- Findings: ${summary.counts.findings}
+- Warning findings: ${summary.counts.warning_findings}
+- Error findings: ${summary.counts.error_findings}
+- Blocker findings: ${summary.counts.blocker_findings}
+- Artifacts: ${summary.counts.artifacts}
+- Filesystem files: ${summary.counts.filesystem_files}
+- Import graph nodes: ${summary.counts.import_nodes}
+- Import graph edges: ${summary.counts.import_edges}
+- Checksums: ${summary.counts.checksums}
+- Exceptions: ${summary.counts.exceptions}
+
+## Output Artifacts
+- \`${summary.outputs.report_path}\`
+- \`${summary.outputs.summary_path}\`
+`;
+}
+function buildCounts(value, findings) {
+    return {
+        findings: findings.length,
+        warning_findings: findings.filter((finding) => finding.severity === 'warn').length,
+        error_findings: findings.filter((finding) => finding.severity === 'error').length,
+        blocker_findings: findings.filter((finding) => finding.severity === 'blocker').length,
+        artifacts: readArray(value, ['run', 'artifacts']).length,
+        filesystem_files: readArray(value, ['filesystem_snapshot', 'files']).length,
+        import_nodes: readArray(value, ['import_graph', 'nodes']).length,
+        import_edges: readArray(value, ['import_graph', 'edges']).length,
+        checksums: readArray(value, ['checksums']).length,
+        exceptions: readArray(value, ['exceptions']).length,
+    };
+}
+function deriveRendererStatus(valid, runStatus, findings) {
+    if (!valid || runStatus !== 'passed') {
+        return 'warning';
+    }
+    return findings.some((finding) => finding.severity !== 'info') ? 'warning' : 'passed';
+}
+function extractRunId(value) {
+    const runId = extractString(value, ['run', 'run_id']);
+    if (!runId || !RUN_ID_PATTERN.test(runId)) {
+        throw new Error('Quality evidence bundle requires a safe run.run_id before report rendering.');
+    }
+    return runId;
+}
+function extractFindings(value) {
+    return readArray(value, ['run', 'findings']).flatMap((item) => {
+        const record = asRecord(item);
+        if (!record) {
+            return [];
+        }
+        const code = readString(record, 'code');
+        const severity = readString(record, 'severity');
+        const message = readString(record, 'message');
+        const remediation = readString(record, 'remediation');
+        if (!code || !severity || !message || !remediation) {
+            return [];
+        }
+        return [{
+                code,
+                severity,
+                message,
+                remediation,
+                path: readString(record, 'path'),
+                gate_id: readString(record, 'gate_id'),
+            }];
+    });
+}
+function normalizeTimestamp(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === 'string') {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? value : parsed.toISOString();
+    }
+    return new Date().toISOString();
+}
+function extractString(value, segments) {
+    let current = value;
+    for (const segment of segments) {
+        const record = asRecord(current);
+        if (!record) {
+            return undefined;
+        }
+        current = record[segment];
+    }
+    return typeof current === 'string' ? current : undefined;
+}
+function readArray(value, segments) {
+    let current = value;
+    for (const segment of segments) {
+        const record = asRecord(current);
+        if (!record) {
+            return [];
+        }
+        current = record[segment];
+    }
+    return Array.isArray(current) ? current : [];
+}
+function asRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function escapeCell(value) {
+    return value.replace(/\|/gu, '\\|').replace(/\n/gu, '<br>');
+}
+//# sourceMappingURL=quality-evidence-renderer.js.map

package/dist/core/sdd/quality-scenario-runner.d.ts

@@ -0,0 +1,42 @@
+import { type PluginArtifactManifest } from './plugin-broker.js';
+import { type PluginComplianceIndex, type PluginValidationManifest } from './plugin-evidence.js';
+import { type QualityArchitectureSchema, type QualityEvidenceBundle, type QualityFilesystemSnapshot, type QualityImportGraph, type QualityRun, type QualityScenario } from './quality-validation.js';
+type QualityRunFinding = QualityRun['findings'][number];
+type QualityRunStatus = QualityRun['status'];
+export interface QualityScenarioRunnerFindingInput {
+    code: string;
+    severity?: QualityRunFinding['severity'];
+    message: string;
+    remediation?: string;
+    path?: string;
+    gate_id?: string;
+}
+export interface QualityScenarioArchitectureResult {
+    schema?: QualityArchitectureSchema;
+    status?: QualityRunStatus;
+    findings?: QualityScenarioRunnerFindingInput[];
+    filesystem_snapshot?: QualityFilesystemSnapshot;
+    import_graph?: QualityImportGraph;
+    artifacts?: string[];
+}
+export interface RunQualityScenarioWarningOnlyInput {
+    scenario: QualityScenario;
+    featureRef?: string;
+    artifactManifest?: PluginArtifactManifest;
+    architectureResult?: QualityScenarioArchitectureResult;
+    validationManifest?: PluginValidationManifest;
+    complianceIndex?: PluginComplianceIndex;
+    startedAt?: Date | string;
+    finishedAt?: Date | string;
+    runId?: string;
+    commandArgv?: string[];
+    cwd?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface QualityScenarioWarningOnlyRunResult {
+    run: QualityRun;
+    evidence_bundle: QualityEvidenceBundle;
+}
+export declare function runQualityScenarioWarningOnly(input: RunQualityScenarioWarningOnlyInput): QualityScenarioWarningOnlyRunResult;
+export {};
+//# sourceMappingURL=quality-scenario-runner.d.ts.map