npm - @dailephd/my-dev-kit-lab - Versions diffs - 0.2.0 - Mend

@dailephd/my-dev-kit-lab 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (250) hide show

package/dist/src/report/renderExperimentHtmlReport.js ADDED Viewed

@@ -0,0 +1,354 @@
+export function renderExperimentHtmlReport(report) {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(report.title)}</title>
+  <style>
+    :root { color-scheme: light; font-family: Arial, Helvetica, sans-serif; }
+    body { margin: 0; color: #17212b; background: #f5f7fa; }
+    main { max-width: 1180px; margin: 0 auto; padding: 28px; }
+    h1 { font-size: 34px; margin: 0 0 8px; }
+    h2 { font-size: 24px; margin: 0 0 14px; }
+    h3 { font-size: 18px; margin: 18px 0 8px; }
+    p, li { line-height: 1.45; }
+    code, pre { font-family: Consolas, "Courier New", monospace; }
+    pre { white-space: pre-wrap; word-break: break-word; background: #101820; color: #f4f7fb; padding: 14px; border-radius: 6px; overflow: auto; }
+    table { width: 100%; border-collapse: collapse; margin: 10px 0 18px; background: #fff; }
+    th, td { border: 1px solid #d9e1ea; padding: 8px 10px; text-align: left; vertical-align: top; }
+    th { background: #edf2f7; }
+    .hero, section { background: #fff; border: 1px solid #d7e0ea; border-radius: 8px; padding: 20px; margin-bottom: 18px; }
+    .muted { color: #5b6b7b; }
+    .grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 12px; }
+    .card { border: 1px solid #d9e1ea; border-radius: 6px; padding: 12px; background: #fbfcfe; }
+    .metric { font-size: 26px; font-weight: 700; margin-top: 6px; }
+    .badge { display: inline-block; border-radius: 999px; padding: 3px 9px; font-size: 12px; font-weight: 700; text-transform: uppercase; background: #e8eef7; }
+    .status-completed, .answer-yes, .status-pass { background: #dcf4e4; color: #0c6b30; }
+    .status-failed, .status-invalid-output, .answer-no, .status-fail { background: #fde2e2; color: #8a1f1f; }
+    .status-timeout, .status-agent-limit-reached, .answer-mixed { background: #fff0ce; color: #785400; }
+    .status-agent-unavailable, .status-skipped, .answer-unavailable, .answer-inconclusive { background: #ece8ff; color: #5639a8; }
+    .two { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 14px; }
+    .small { font-size: 13px; }
+    .note { margin: 8px 0 14px; padding: 10px 12px; border-left: 4px solid #537895; background: #f4f8fc; color: #324255; }
+    @media (max-width: 900px) { main { padding: 16px; } .grid, .two { grid-template-columns: 1fr; } table { font-size: 13px; } }
+  </style>
+</head>
+<body>
+<main>
+  <header class="hero">
+    <h1>${escapeHtml(report.title)}</h1>
+    <p>${escapeHtml(report.subtitle)}</p>
+    <p class="muted">Generated ${escapeHtml(report.generatedAt)} from <code>${escapeHtml(report.sourceExperimentDir)}</code></p>
+  </header>
+  <section id="executive-summary">
+    <h2>Executive Summary</h2>
+    <p>${escapeHtml(report.executiveSummary.summaryText)}</p>
+    <div class="grid">
+      ${answerCard("Does my-dev-kit save tokens?", report.executiveSummary.doesMyDevKitSaveTokens)}
+      ${answerCard("Does my-dev-kit preserve correctness?", report.executiveSummary.doesMyDevKitPreserveCorrectness)}
+      ${answerCard("Does my-dev-kit reduce execution time?", report.executiveSummary.doesMyDevKitReduceExecutionTime)}
+    </div>
+    <div class="grid">
+      ${metricCard("Completed runs", report.executiveSummary.completedRuns)}
+      ${metricCard("Failed runs", report.executiveSummary.failedRuns)}
+      ${metricCard("Unavailable runs", report.executiveSummary.unavailableRuns)}
+      ${metricCard("External limits", report.executiveSummary.limitReachedRuns)}
+      ${metricCard("Timeouts", report.executiveSummary.timeoutRuns)}
+      ${metricCard("Invalid output", report.executiveSummary.invalidOutputRuns)}
+    </div>
+    <h3>Comparison Reliability</h3>
+    ${note("Reliability label describes whether a comparison had completed runs, available token counts, and valid scores. Strong means both runs completed and token comparison was available.")}
+    ${keyValueTable(report.executiveSummary.comparisonReliabilityCounts)}
+  </section>
+  <section id="methodology">
+    <h2>Methodology</h2>
+    ${list(report.methodology)}
+  </section>
+  <section id="projects">
+    <h2>Benchmark Projects</h2>
+    ${note("Complexity score is a 0-100 weighted score based on source file count, source lines, language count, internal imports, max file size, and expected relevant context size. Higher means the project should be harder for raw full-file reading.")}
+    ${report.projectProfiles.map(renderProject).join("")}
+  </section>
+  <section id="file-trees">
+    <h2>File Trees</h2>
+    ${note("File tree entries show the compact benchmark layout used by prompts and reports: each row lists the relative path, its role, detected language, and line count.")}
+    ${report.fileTreeSections.map(renderFileTree).join("")}
+  </section>
+  <section id="benchmark-tasks">
+    <h2>Benchmark Tasks</h2>
+    ${note("Expected files, symbols, and facts come from deterministic answer keys. They drive correctness scoring and help show how much context a task should need.")}
+    ${report.benchmarkCases.map(renderBenchmarkCase).join("")}
+  </section>
+  <section id="prompts">
+    <h2>Prompt Strategies</h2>
+    ${note("Prompt metrics summarize prompt size and structure. Higher prompt chars or estimated tokens mean more instruction overhead before the agent starts its own work.")}
+    ${report.promptComparisonSections.map(renderPrompt).join("")}
+  </section>
+  <section id="agent-runs">
+    <h2>Agent Runs</h2>
+    ${note("Run status records whether the agent completed, failed, timed out, was unavailable, hit a usage/session limit, or returned invalid output. Token source and reliability describe how trustworthy the token counts are for that run.")}
+    ${renderRuns(report.agentRunSections)}
+  </section>
+  <section id="correctness">
+    <h2>Correctness Results</h2>
+    ${note("Correctness score is deterministic and answer-key based: 25% expected files, 25% expected symbols, 50% expected facts. It is not an LLM judge.")}
+    ${renderCorrectness(report.correctnessSections)}
+  </section>
+  <section id="tokens">
+    <h2>Token Results</h2>
+    ${note("Token savings percent is computed as (rawTotalTokens - myDevKitTotalTokens) / rawTotalTokens * 100. Positive means my-dev-kit used fewer tokens. Negative means my-dev-kit used more tokens.")}
+    ${renderTokenComparisons(report.tokenSections)}
+  </section>
+  <section id="timing">
+    <h2>Timing Results</h2>
+    ${note("Duration reduction percent is computed as (rawDurationMs - myDevKitDurationMs) / rawDurationMs * 100. Positive means my-dev-kit was faster. Negative means it was slower.")}
+    ${renderTimingComparisons(report.timingSections)}
+  </section>
+  <section id="comparisons">
+    <h2>Raw vs my-dev-kit Comparisons</h2>
+    ${note("This table joins the paired raw-full-file and my-dev-kit-guided runs for the same agent, case, and prompt complexity so token, timing, and correctness differences are directly comparable.")}
+    ${renderComparisons(report.comparisonSections)}
+  </section>
+  ${report.plotSections.length ? `<section id="plots"><h2>Plots</h2>${renderPlots(report.plotSections)}</section>` : ""}
+  ${report.visualizationSections.length
+        ? `<section id="visualization-demos"><h2>my-dev-kit Visualization Demos</h2>${renderVisualizations(report.visualizationSections)}</section>`
+        : ""}
+  <section id="formulas">
+    <h2>Formulas</h2>
+    ${note("Full metric definitions live in docs/METRICS.md. The artifact index below links to that glossary alongside the experiment JSON artifacts.")}
+    ${report.formulaSections
+        .map((section) => `<div class="card"><h3>${escapeHtml(section.title)}</h3><pre>${escapeHtml(section.formula)}</pre>${list(section.notes)}</div>`)
+        .join("")}
+  </section>
+  <section id="warnings">
+    <h2>Warnings and Limitations</h2>
+    <h3>Warnings</h3>
+    ${report.warnings.length ? list(report.warnings) : "<p>No warnings.</p>"}
+    <h3>Limitations</h3>
+    ${list(report.limitations)}
+  </section>
+  <section id="artifacts">
+    <h2>Artifact Index</h2>
+    ${table(["Label", "Kind", "Path"], report.artifactLinks.map((artifact) => [artifact.label, artifact.kind, artifact.path]))}
+  </section>
+  <section id="next-steps">
+    <h2>Next Steps</h2>
+    ${list(report.nextSteps)}
+  </section>
+</main>
+</body>
+</html>`;
+}
+function renderProject(section) {
+    const profile = section.profile;
+    return `<div class="card">
+    <h3>${escapeHtml(profile.displayName)} <span class="muted">(${escapeHtml(profile.projectId)})</span></h3>
+    <p>${escapeHtml(profile.description)}</p>
+    ${table(["Field", "Value"], [
+        ["Primary language", profile.primaryLanguage],
+        ["Languages", profile.languages.join(", ")],
+        ["Language mix", profile.languageMix],
+        ["Benchmark purpose", profile.benchmarkPurpose],
+        ["Expected use cases", profile.expectedUseCases.join(", ")],
+        ["Complexity level", profile.complexityLevel],
+        ["Complexity score", String(profile.complexityScore)],
+        ["Complexity formula", profile.complexityFormula.id]
+    ])}
+    <h3>Complexity Metrics</h3>
+    ${keyValueTable(section.complexityMetrics)}
+  </div>`;
+}
+function renderFileTree(section) {
+    return `<div class="card">
+    <h3>${escapeHtml(section.projectId)}</h3>
+    ${table(["Path", "Role", "Language", "Lines"], section.entries.map((entry) => [entry.path, entry.role, entry.language ?? "", entry.lines === undefined ? "" : String(entry.lines)]))}
+    ${section.truncated ? `<p class="muted">Showing ${section.entries.length} of ${section.totalEntries} entries.</p>` : ""}
+  </div>`;
+}
+function renderBenchmarkCase(section) {
+    return `<div class="card">
+    <h3>${escapeHtml(section.title)} <span class="muted">(${escapeHtml(section.caseId)})</span></h3>
+    ${table(["Field", "Value"], [
+        ["Benchmark project", section.benchmarkProject],
+        ["Task/query", section.query],
+        ["Expected operation", section.expectedOperation ?? ""],
+        ["Expected files", section.expectedFiles.join(", ")],
+        ["Expected symbols", section.expectedSymbols.join(", ")],
+        ["Minimum correct facts", String(section.minimumCorrectFacts)],
+        ["Notes", section.notes ?? ""]
+    ])}
+    <h3>Expected Facts Summary</h3>
+    ${table(["ID", "Required", "Weight", "Text"], section.expectedFacts.map((fact) => [fact.id, String(fact.required), String(fact.weight), fact.text]))}
+  </div>`;
+}
+function renderPrompt(section) {
+    return `<details class="card" open>
+    <summary><strong>${escapeHtml(section.strategy)}</strong> ${escapeHtml(section.complexityLevel)} for ${escapeHtml(section.agentId)}</summary>
+    ${table(["Metric", "Value"], [
+        ["Run ID", section.runId],
+        ["Prompt path", section.promptPath ?? ""],
+        ["Prompt estimated tokens", String(section.metrics.promptEstimatedTokens)],
+        ["Prompt chars", String(section.metrics.promptChars)],
+        ["Instruction count", String(section.metrics.instructionCount)],
+        ["Constraint count", String(section.metrics.constraintCount)],
+        ["Requested output fields", String(section.metrics.requestedOutputFieldCount)],
+        ["Task step count", String(section.metrics.taskStepCount)],
+        ["Expected fact count", String(section.metrics.expectedFactCount)],
+        ["Expected file count", String(section.metrics.expectedFileCount)],
+        ["Expected symbol count", String(section.metrics.expectedSymbolCount)],
+        ["Graph-guided retrieval required", String(section.metrics.requiresGraphGuidedRetrieval)],
+        ["Command execution required", String(section.metrics.requiresCommandExecution)]
+    ])}
+    <pre>${escapeHtml(section.promptExcerpt)}</pre>
+    ${section.promptWasTruncated ? "<p class=\"muted\">Prompt excerpt truncated; see artifact path for full prompt.</p>" : ""}
+  </details>`;
+}
+function renderRuns(runs) {
+    return table(["Run ID", "Agent", "Strategy", "Complexity", "Status", "Reason", "Duration", "Exit", "Input", "Output", "Total", "Token Source", "Correctness", "Artifacts"], runs.map((run) => [
+        run.runId,
+        run.agentId,
+        run.promptStrategy,
+        run.promptComplexityLevel,
+        run.status,
+        run.statusReason,
+        `${run.durationMs} ms`,
+        run.agentRunResult.exitCode === null ? "" : String(run.agentRunResult.exitCode),
+        run.tokenUsage.inputTokens === undefined ? "unavailable" : String(run.tokenUsage.inputTokens),
+        run.tokenUsage.outputTokens === undefined ? "unavailable" : String(run.tokenUsage.outputTokens),
+        run.tokenUsage.totalTokens === undefined ? "unavailable" : String(run.tokenUsage.totalTokens),
+        `${run.tokenUsageSource} / ${run.tokenUsageReliability}`,
+        `${run.correctness.correctnessScore} (${run.correctness.passed ? "pass" : "fail"})`,
+        [run.artifactPaths.promptPath, run.artifactPaths.agentRunResultPath, run.artifactPaths.parsedAnswerPath, run.artifactPaths.correctnessScorePath]
+            .filter(Boolean)
+            .join("\n")
+    ]));
+}
+function renderPlots(plots) {
+    return table(["Plot", "Kind", "Path"], plots.map((plot) => [plot.title, plot.kind, plot.path]));
+}
+function renderVisualizations(demos) {
+    return table(["Command", "Status", "Duration", "Artifacts", "Warnings"], demos.map((demo) => [
+        demo.name,
+        demo.status,
+        `${demo.durationMs} ms`,
+        demo.producedArtifactPaths.join("\n"),
+        demo.warnings.join("; ")
+    ]));
+}
+function renderCorrectness(runs) {
+    return table(["Run ID", "File", "Symbol", "Fact", "Score", "Required facts", "Files", "Symbols", "Failure reasons"], runs.map((run) => [
+        run.runId,
+        String(run.correctness.fileMatchScore),
+        String(run.correctness.symbolMatchScore),
+        String(run.correctness.factMatchScore),
+        String(run.correctness.correctnessScore),
+        `${run.correctness.requiredFactsFound}/${run.correctness.requiredFactsTotal}`,
+        `${run.correctness.expectedFilesFound}/${run.correctness.expectedFilesTotal}`,
+        `${run.correctness.expectedSymbolsFound}/${run.correctness.expectedSymbolsTotal}`,
+        run.correctness.failureReasons.join("; ")
+    ]));
+}
+function renderTokenComparisons(comparisons) {
+    return table(["Comparison", "Raw tokens", "my-dev-kit tokens", "Token delta", "Savings percent", "Available", "Warnings"], comparisons.map((comparison) => [
+        comparison.comparisonId,
+        comparison.rawTotalTokens === undefined ? "missing" : String(comparison.rawTotalTokens),
+        comparison.myDevKitTotalTokens === undefined ? "missing" : String(comparison.myDevKitTotalTokens),
+        comparison.tokenDelta === undefined ? "unavailable" : String(comparison.tokenDelta),
+        comparison.tokenSavingsPercent === undefined ? "unavailable" : `${comparison.tokenSavingsPercent}%`,
+        String(comparison.tokenComparisonAvailable),
+        comparison.warnings.join("; ")
+    ]));
+}
+function renderTimingComparisons(comparisons) {
+    return table(["Comparison", "Raw duration", "my-dev-kit duration", "Delta", "Reduction percent", "Reliability"], comparisons.map((comparison) => [
+        comparison.comparisonId,
+        comparison.rawDurationMs === undefined ? "missing" : `${comparison.rawDurationMs} ms`,
+        comparison.myDevKitDurationMs === undefined ? "missing" : `${comparison.myDevKitDurationMs} ms`,
+        comparison.durationDeltaMs === undefined ? "unavailable" : `${comparison.durationDeltaMs} ms`,
+        comparison.durationReductionPercent === undefined ? "unavailable" : `${comparison.durationReductionPercent}%`,
+        comparison.reliabilityLabel
+    ]));
+}
+function renderComparisons(comparisons) {
+    return table([
+        "Comparison ID",
+        "Case",
+        "Project",
+        "Agent",
+        "Complexity",
+        "Raw run",
+        "my-dev-kit run",
+        "Raw status",
+        "my-dev-kit status",
+        "Raw correctness",
+        "my-dev-kit correctness",
+        "Same pass",
+        "Token savings",
+        "Duration reduction",
+        "Reliability",
+        "Warnings"
+    ], comparisons.map((comparison) => [
+        comparison.comparisonId,
+        comparison.caseId,
+        comparison.benchmarkProject,
+        comparison.agentId,
+        comparison.complexityLevel,
+        comparison.rawRunId ?? "",
+        comparison.myDevKitRunId ?? "",
+        comparison.rawStatus ?? "",
+        comparison.myDevKitStatus ?? "",
+        comparison.rawCorrectnessScore === undefined ? "" : String(comparison.rawCorrectnessScore),
+        comparison.myDevKitCorrectnessScore === undefined ? "" : String(comparison.myDevKitCorrectnessScore),
+        String(comparison.sameCorrectnessPass),
+        comparison.tokenSavingsPercent === undefined ? "unavailable" : `${comparison.tokenSavingsPercent}%`,
+        comparison.durationReductionPercent === undefined ? "unavailable" : `${comparison.durationReductionPercent}%`,
+        comparison.reliabilityLabel,
+        comparison.warnings.join("; ")
+    ]));
+}
+function answerCard(label, answer) {
+    return `<div class="card"><div>${escapeHtml(label)}</div><div class="metric"><span class="badge answer-${escapeHtml(answer)}">${escapeHtml(answer)}</span></div></div>`;
+}
+function metricCard(label, value) {
+    return `<div class="card"><div>${escapeHtml(label)}</div><div class="metric">${escapeHtml(value)}</div></div>`;
+}
+function keyValueTable(values) {
+    return table(["Metric", "Value"], Object.entries(values).map(([key, value]) => [key, value === undefined ? "" : String(value)]));
+}
+function note(text) {
+    return `<p class="note small">${escapeHtml(text)}</p>`;
+}
+function table(headers, rows, allowHtml = false) {
+    return `<table><thead><tr>${headers.map((header) => `<th>${escapeHtml(header)}</th>`).join("")}</tr></thead><tbody>${rows
+        .map((row) => `<tr>${row.map((cell) => `<td>${allowHtml ? cell : escapeHtml(cell)}</td>`).join("")}</tr>`)
+        .join("")}</tbody></table>`;
+}
+function list(items) {
+    return `<ul>${items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul>`;
+}
+function escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}

package/dist/src/report/renderHtmlReport.js ADDED Viewed

@@ -0,0 +1,103 @@
+function escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function renderWarnings(warnings) {
+    if (warnings.length === 0) {
+        return "<p data-testid=\"warnings-empty\">No warnings.</p>";
+    }
+    return `<ul>${warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join("")}</ul>`;
+}
+export function renderHtmlReport(report) {
+    const stepsHtml = report.steps
+        .map((step) => `
+        <li class="card step" data-testid="step-${escapeHtml(step.id)}">
+          <div class="row"><strong>${escapeHtml(step.label)}</strong><span class="badge status-${escapeHtml(step.status)}">${escapeHtml(step.status)}</span></div>
+          ${step.command ? `<div class="muted"><code>${escapeHtml(step.command)}</code></div>` : ""}
+          ${typeof step.durationMs === "number" ? `<div class="muted">Duration: ${escapeHtml(step.durationMs)} ms</div>` : ""}
+          ${step.notes ? `<div>${escapeHtml(step.notes)}</div>` : ""}
+        </li>`)
+        .join("");
+    const metricsHtml = report.metrics
+        .map((metric) => `
+        <li class="card metric" data-testid="metric-${escapeHtml(metric.id)}">
+          <div><strong>${escapeHtml(metric.label)}</strong></div>
+          <div class="metric-value">${escapeHtml(metric.value)}${metric.unit ? ` ${escapeHtml(metric.unit)}` : ""}</div>
+          ${metric.interpretation ? `<div class="muted">${escapeHtml(metric.interpretation)}</div>` : ""}
+        </li>`)
+        .join("");
+    const artifactsHtml = report.artifacts
+        .map((artifact) => `
+        <li class="card artifact" data-testid="artifact-${escapeHtml(artifact.id)}">
+          <div class="row"><strong>${escapeHtml(artifact.label)}</strong><span class="badge">${escapeHtml(artifact.kind)}</span></div>
+          <div><code>${escapeHtml(artifact.path)}</code></div>
+        </li>`)
+        .join("");
+    return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(report.title)}</title>
+    <style>
+      :root { color-scheme: light; font-family: Arial, Helvetica, sans-serif; }
+      body { margin: 0; background: #f4f6fb; color: #16202a; }
+      main { max-width: 1120px; margin: 0 auto; padding: 32px; }
+      h1, h2 { margin: 0 0 12px; }
+      h1 { font-size: 32px; }
+      h2 { font-size: 22px; margin-top: 28px; }
+      p { line-height: 1.5; }
+      .hero, .section, .card { background: #ffffff; border: 1px solid #d8e0ea; border-radius: 8px; }
+      .hero { padding: 24px; }
+      .section { padding: 20px; margin-top: 20px; }
+      .meta { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; margin-top: 18px; }
+      .row { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+      .grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 16px; padding: 0; list-style: none; }
+      .stack { padding: 0; list-style: none; display: grid; gap: 12px; }
+      .card { padding: 16px; }
+      .badge { display: inline-block; padding: 4px 10px; background: #e8eef8; border-radius: 999px; font-size: 12px; text-transform: uppercase; }
+      .status-pass { background: #dff5e3; color: #0e6b2f; }
+      .status-fail { background: #fde2e2; color: #8a1f1f; }
+      .status-skipped { background: #ece8ff; color: #5e41b7; }
+      .muted { color: #546474; margin-top: 6px; }
+      .metric-value { font-size: 28px; margin-top: 8px; }
+      code { font-family: Consolas, monospace; font-size: 14px; word-break: break-word; }
+      @media (max-width: 800px) { .meta, .grid { grid-template-columns: 1fr; } main { padding: 20px; } }
+    </style>
+  </head>
+  <body>
+    <main>
+      <section class="hero" data-testid="report-header">
+        <h1>${escapeHtml(report.title)}</h1>
+        <p>${escapeHtml(report.summary)}</p>
+        <div class="meta">
+          <div><strong>Project name</strong><div>${escapeHtml(report.projectName)}</div></div>
+          <div><strong>Benchmark project</strong><div>${escapeHtml(report.benchmarkProject)}</div></div>
+          <div><strong>Workflow name</strong><div>${escapeHtml(report.workflowName)}</div></div>
+          <div><strong>Generated timestamp</strong><div>${escapeHtml(report.generatedAt)}</div></div>
+        </div>
+      </section>
+      <section class="section" data-testid="workflow-steps">
+        <h2>Workflow steps</h2>
+        <ul class="stack">${stepsHtml}</ul>
+      </section>
+      <section class="section" data-testid="metrics">
+        <h2>Metrics</h2>
+        <ul class="grid">${metricsHtml}</ul>
+      </section>
+      <section class="section" data-testid="artifacts">
+        <h2>Artifacts</h2>
+        <ul class="stack">${artifactsHtml}</ul>
+      </section>
+      <section class="section" data-testid="warnings">
+        <h2>Warnings</h2>
+        ${renderWarnings(report.warnings)}
+      </section>
+    </main>
+  </body>
+</html>`;
+}

package/dist/src/report/types.js ADDED Viewed

@@ -0,0 +1,10 @@
+export function normalizeLabReport(input, generatedAt) {
+    return {
+        ...input,
+        generatedAt: generatedAt ?? input.generatedAt ?? new Date().toISOString(),
+        steps: input.steps.map((step) => ({ ...step })),
+        metrics: input.metrics.map((metric) => ({ ...metric })),
+        artifacts: input.artifacts.map((artifact) => ({ ...artifact })),
+        warnings: [...input.warnings]
+    };
+}

package/dist/src/report/writeExperimentReportArtifacts.js ADDED Viewed

@@ -0,0 +1,38 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWithinRoot } from "../core/pathSafety.js";
+import { renderExperimentHtmlReport } from "./renderExperimentHtmlReport.js";
+export function getExperimentReportArtifactPaths(outDir) {
+    const resolvedOutDir = path.resolve(outDir);
+    return {
+        outDir: resolvedOutDir,
+        jsonPath: resolveWithinRoot(resolvedOutDir, "experiment-report.json"),
+        htmlPath: resolveWithinRoot(resolvedOutDir, "experiment-report.html"),
+        pngPath: resolveWithinRoot(resolvedOutDir, "experiment-report.png"),
+        artifactIndexPath: resolveWithinRoot(resolvedOutDir, "experiment-report-artifacts.json")
+    };
+}
+export async function writeExperimentReportArtifacts(args) {
+    const outputPaths = getExperimentReportArtifactPaths(args.outDir);
+    await mkdir(outputPaths.outDir, { recursive: true });
+    const warnings = [...args.report.warnings];
+    if (args.screenshot.warning) {
+        warnings.push(args.screenshot.warning);
+    }
+    if (args.screenshot.status === "failed" && args.screenshot.error) {
+        warnings.push(`PNG screenshot capture failed: ${args.screenshot.error}`);
+    }
+    const report = {
+        ...args.report,
+        warnings
+    };
+    await writeFile(outputPaths.htmlPath, renderExperimentHtmlReport(report), "utf8");
+    await writeFile(outputPaths.jsonPath, `${JSON.stringify({ report, generatedAt: report.generatedAt, outputPaths, screenshot: args.screenshot, warnings }, null, 2)}\n`, "utf8");
+    await writeFile(outputPaths.artifactIndexPath, `${JSON.stringify({ generatedAt: report.generatedAt, outputPaths, sourceExperimentDir: report.sourceExperimentDir, artifactLinks: report.artifactLinks }, null, 2)}\n`, "utf8");
+    return {
+        report,
+        outputPaths,
+        screenshot: args.screenshot,
+        warnings
+    };
+}

package/dist/src/report/writeReportArtifacts.js ADDED Viewed

@@ -0,0 +1,39 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { renderHtmlReport } from "./renderHtmlReport.js";
+import { normalizeLabReport } from "./types.js";
+export function getReportArtifactPaths(outDir, reportId) {
+    return {
+        outDir,
+        jsonPath: path.join(outDir, `${reportId}.json`),
+        htmlPath: path.join(outDir, `${reportId}.html`),
+        pngPath: path.join(outDir, `${reportId}.png`)
+    };
+}
+export async function writeReportArtifacts(options) {
+    const report = normalizeLabReport(options.report, options.generatedAt);
+    const outputPaths = getReportArtifactPaths(options.outDir, report.reportId);
+    const warnings = [...report.warnings];
+    if (options.screenshot.warning) {
+        warnings.push(options.screenshot.warning);
+    }
+    if (options.screenshot.status === "failed" && options.screenshot.error) {
+        warnings.push(`PNG screenshot capture failed: ${options.screenshot.error}`);
+    }
+    await mkdir(outputPaths.outDir, { recursive: true });
+    await writeFile(outputPaths.htmlPath, renderHtmlReport(report), "utf8");
+    const payload = {
+        report,
+        generatedAt: report.generatedAt,
+        outputPaths,
+        screenshot: options.screenshot,
+        warnings
+    };
+    await writeFile(outputPaths.jsonPath, JSON.stringify(payload, null, 2), "utf8");
+    return {
+        report,
+        outputPaths,
+        screenshot: options.screenshot,
+        warnings
+    };
+}

package/dist/src/screenshot/captureReportScreenshot.js ADDED Viewed

@@ -0,0 +1,75 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const SKIP_WARNING = "PNG screenshot skipped because Playwright or browser runtime is unavailable.";
+function isMissingBrowserRuntime(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return (message.includes("Executable doesn't exist") ||
+        message.includes("browserType.launch") ||
+        message.includes("playwright install") ||
+        message.includes("Failed to launch") ||
+        message.includes("Could not find Chrome") ||
+        message.includes("ENOENT"));
+}
+async function defaultLoadPlaywright() {
+    return (await import("playwright"));
+}
+export async function captureReportScreenshot(htmlPath, pngPath, options) {
+    const loadPlaywright = options?.loadPlaywright ?? defaultLoadPlaywright;
+    try {
+        await access(htmlPath);
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            htmlPath,
+            pngPath,
+            error: `HTML report not found: ${htmlPath}`
+        };
+    }
+    let playwright;
+    try {
+        playwright = await loadPlaywright();
+    }
+    catch {
+        return {
+            status: "skipped",
+            htmlPath,
+            pngPath,
+            warning: SKIP_WARNING
+        };
+    }
+    let browser;
+    try {
+        browser = await playwright.chromium.launch({ headless: true });
+        const page = await browser.newPage({ viewport: { width: 1440, height: 1080 } });
+        await page.goto(pathToFileURL(path.resolve(htmlPath)).href, { waitUntil: "load" });
+        await page.screenshot({ path: pngPath, fullPage: true });
+        await browser.close();
+        return {
+            status: "captured",
+            htmlPath,
+            pngPath
+        };
+    }
+    catch (error) {
+        if (browser) {
+            await browser.close().catch(() => undefined);
+        }
+        if (isMissingBrowserRuntime(error)) {
+            return {
+                status: "skipped",
+                htmlPath,
+                pngPath,
+                warning: SKIP_WARNING
+            };
+        }
+        return {
+            status: "failed",
+            htmlPath,
+            pngPath,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+export { SKIP_WARNING as SCREENSHOT_SKIP_WARNING };

package/dist/src/screenshot/index.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./types.js";
2	+ export * from "./captureReportScreenshot.js";

package/dist/src/screenshot/types.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/src/securityValidation/artifacts.js ADDED Viewed

@@ -0,0 +1,15 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+// Write a structured security check result to the reports/security directory.
+// Raw stdout/stderr are written to reports/security/raw/ as separate text files.
+export async function writeCheckResult(options) {
+    await mkdir(path.dirname(options.outputPath), { recursive: true });
+    await mkdir(options.rawDir, { recursive: true });
+    if (options.rawStdout !== undefined) {
+        await writeFile(path.join(options.rawDir, `${options.result.id}.stdout.txt`), options.rawStdout, "utf8");
+    }
+    if (options.rawStderr !== undefined) {
+        await writeFile(path.join(options.rawDir, `${options.result.id}.stderr.txt`), options.rawStderr, "utf8");
+    }
+    await writeFile(options.outputPath, JSON.stringify(options.result, null, 2), "utf8");
+}