stilltrue 0.1.0 → 0.2.0

package/dist/cli.js

@@ -6,9 +6,12 @@
  * outage must not block CI), 1 = rot detected or usage error.
  */
 import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { findConfigPath, loadConfig } from "./loadConfig.js";
 import { runDrift } from "./runner.js";
+import { DEFAULT_HISTORY_PATH, loadHistory, recordRun } from "./history.js";
+import { renderReport } from "./report.js";
 const GH = !!process.env.GITHUB_ACTIONS;
 function printResult(r) {
     const icon = { pass: '✓', rot: '✗', error: '⚠' }[r.outcome];
@@ -31,6 +34,8 @@ async function drift(argv) {
             config: { type: 'string' },
             only: { type: 'string' },
             json: { type: 'string' },
+            record: { type: 'boolean' },
+            history: { type: 'string' },
         },
     });
     const configPath = findConfigPath(process.cwd(), values.config);
@@ -53,21 +58,49 @@ async function drift(argv) {
         await writeFile(values.json, JSON.stringify(results, null, 2));
         console.log(`results written to ${values.json}`);
     }
+    if (values.record) {
+        const historyPath = resolve(values.history ?? DEFAULT_HISTORY_PATH);
+        await recordRun(results, historyPath);
+        console.log(`run recorded to ${historyPath}`);
+    }
     return rotted > 0 ? 1 : 0;
 }
+async function report(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            history: { type: 'string' },
+            out: { type: 'string' },
+            title: { type: 'string' },
+        },
+    });
+    const historyPath = resolve(values.history ?? DEFAULT_HISTORY_PATH);
+    const history = await loadHistory(historyPath);
+    if (!history.length) {
+        console.error(`no recorded runs at ${historyPath} — run \`stilltrue drift --record\` first (use --history to point elsewhere)`);
+        return 1;
+    }
+    const out = resolve(values.out ?? 'stilltrue-report.html');
+    await writeFile(out, renderReport(history, values.title));
+    console.log(`report written to ${out} (${history.length} runs)`);
+    return 0;
+}
 const [command, ...rest] = process.argv.slice(2);
 try {
     switch (command) {
         case 'drift':
             process.exit(await drift(rest));
             break;
-        case 'golden':
         case 'report':
-            console.error(`stilltrue ${command}: not implemented yet — drift shipped first (docs/BRIEF.md)`);
+            process.exit(await report(rest));
+            break;
+        case 'golden':
+            console.error('stilltrue golden: not implemented yet — drift shipped first (docs/BRIEF.md)');
             process.exit(1);
             break;
         default:
-            console.log('usage: stilltrue drift [--config <path>] [--only <names>] [--json <path>]');
+            console.log('usage: stilltrue drift [--config <path>] [--only <names>] [--json <path>] [--record] [--history <path>]\n' +
+                '       stilltrue report [--history <path>] [--out <path>] [--title <text>]');
             process.exit(command ? 1 : 0);
     }
 }

package/dist/history.d.ts

@@ -0,0 +1,11 @@
+import type { DriftResult } from './config.ts';
+/** One recorded `stilltrue drift` run. */
+export interface RunRecord {
+    at: string;
+    results: DriftResult[];
+}
+export declare const DEFAULT_HISTORY_PATH = ".stilltrue/history.jsonl";
+/** Append a run to the JSONL history file (created on first record). */
+export declare function recordRun(results: DriftResult[], historyPath: string): Promise<RunRecord>;
+/** Load history oldest-first. Missing file → []. Corrupt lines are skipped. */
+export declare function loadHistory(historyPath: string): Promise<RunRecord[]>;

package/dist/history.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, appendFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+export const DEFAULT_HISTORY_PATH = '.stilltrue/history.jsonl';
+/** Append a run to the JSONL history file (created on first record). */
+export async function recordRun(results, historyPath) {
+    const record = { at: new Date().toISOString(), results };
+    await mkdir(dirname(historyPath), { recursive: true });
+    await appendFile(historyPath, JSON.stringify(record) + '\n');
+    return record;
+}
+/** Load history oldest-first. Missing file → []. Corrupt lines are skipped. */
+export async function loadHistory(historyPath) {
+    let raw;
+    try {
+        raw = await readFile(historyPath, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const records = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed && typeof parsed.at === 'string' && Array.isArray(parsed.results)) {
+                records.push(parsed);
+            }
+        }
+        catch {
+            // A truncated line (interrupted CI write) shouldn't sink the report.
+        }
+    }
+    return records;
+}

package/dist/report.d.ts

@@ -0,0 +1,2 @@
+import type { RunRecord } from './history.ts';
+export declare function renderReport(history: RunRecord[], title?: string): string;

package/dist/report.js

@@ -0,0 +1,120 @@
+const STATUS = {
+    pass: { color: '#0ca30c', glyph: '✓', ink: '#ffffff', label: 'pass' },
+    rot: { color: '#d03b3b', glyph: '✗', ink: '#ffffff', label: 'rot' },
+    error: { color: '#fab219', glyph: '⚠', ink: '#1a1a19', label: 'error' },
+};
+const MAX_COLUMNS = 60;
+const MAX_LOG = 50;
+function esc(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+function day(iso) {
+    return iso.slice(5, 10); // MM-DD
+}
+export function renderReport(history, title = 'stilltrue drift report') {
+    const runs = history.slice(-MAX_COLUMNS);
+    const latest = runs[runs.length - 1];
+    // Stable row order: latest run's order first, then any check seen earlier.
+    const names = [];
+    for (const record of [...runs].reverse()) {
+        for (const r of record.results)
+            if (!names.includes(r.name))
+                names.push(r.name);
+    }
+    const counts = { pass: 0, rot: 0, error: 0 };
+    for (const r of latest?.results ?? [])
+        counts[r.outcome]++;
+    const tiles = ['pass', 'rot', 'error']
+        .map((o) => `<div class="tile">
+        <div class="tile-num" style="color:${counts[o] && o !== 'pass' ? STATUS[o].color : 'var(--ink)'}">${counts[o]}</div>
+        <div class="tile-label">${STATUS[o].glyph} ${STATUS[o].label}</div>
+      </div>`)
+        .join('');
+    const headerCells = runs
+        .map((rec, i) => {
+        const sparse = runs.length <= 10 || i % Math.ceil(runs.length / 10) === 0 || i === runs.length - 1;
+        return `<th title="${esc(rec.at)}">${sparse ? day(rec.at) : ''}</th>`;
+    })
+        .join('');
+    const rows = names
+        .map((name) => {
+        const cells = runs
+            .map((rec) => {
+            const r = rec.results.find((x) => x.name === name);
+            if (!r)
+                return '<td><span class="cell none" title="not run"></span></td>';
+            const s = STATUS[r.outcome];
+            const detail = [r.outcome, ...r.messages, ...r.warnings.map((w) => `warning: ${w}`)].join('\n');
+            return `<td><span class="cell" style="background:${s.color};color:${s.ink}" title="${esc(rec.at)}\n${esc(detail)}">${s.glyph}</span></td>`;
+        })
+            .join('');
+        return `<tr><th class="check-name">${esc(name)}</th>${cells}</tr>`;
+    })
+        .join('');
+    const events = [...runs]
+        .reverse()
+        .flatMap((rec) => rec.results
+        .filter((r) => r.outcome !== 'pass' || r.warnings.length)
+        .map((r) => ({ at: rec.at, ...r })))
+        .slice(0, MAX_LOG);
+    const log = events.length
+        ? events
+            .map((e) => {
+            const s = STATUS[e.outcome];
+            const items = [...e.messages, ...e.warnings.map((w) => `warning: ${w}`)]
+                .map((m) => `<li>${esc(m)}</li>`)
+                .join('');
+            return `<details ${e.outcome === 'rot' ? 'open' : ''}>
+            <summary><span class="badge" style="background:${s.color};color:${s.ink}">${s.glyph} ${s.label}</span>
+            <strong>${esc(e.name)}</strong> <span class="muted">${esc(e.at)}</span></summary>
+            <ul>${items}</ul>
+          </details>`;
+        })
+            .join('')
+        : '<p class="muted">Nothing has rotted, errored, or warned in recorded history.</p>';
+    return `<!doctype html>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(title)}</title>
+<style>
+  :root { --bg:#ffffff; --ink:#1a1a19; --ink-2:#5f5e5a; --line:#e4e2dd; --surface:#f6f5f2; }
+  @media (prefers-color-scheme: dark) {
+    :root { --bg:#1a1a19; --ink:#f2f1ee; --ink-2:#a5a39d; --line:#3a3936; --surface:#242422; }
+  }
+  * { box-sizing: border-box; }
+  body { margin:0; padding:2rem 1.5rem; background:var(--bg); color:var(--ink);
+         font:15px/1.5 ui-sans-serif, system-ui, sans-serif; max-width:64rem; margin-inline:auto; }
+  h1 { font-size:1.3rem; margin:0 0 .25rem; }
+  h2 { font-size:1rem; margin:2rem 0 .75rem; }
+  .muted { color:var(--ink-2); font-size:.85rem; }
+  .tiles { display:flex; gap:.75rem; margin:1.25rem 0; flex-wrap:wrap; }
+  .tile { background:var(--surface); border:1px solid var(--line); border-radius:8px;
+          padding:.75rem 1.25rem; min-width:6.5rem; }
+  .tile-num { font-size:1.6rem; font-weight:600; font-variant-numeric:tabular-nums; }
+  .tile-label { color:var(--ink-2); font-size:.85rem; }
+  .grid-wrap { overflow-x:auto; border:1px solid var(--line); border-radius:8px; padding:.75rem; }
+  table { border-collapse:separate; border-spacing:2px; }
+  th { font-weight:500; color:var(--ink-2); font-size:.7rem; text-align:left; white-space:nowrap; }
+  thead th { vertical-align:bottom; padding-bottom:.25rem; }
+  .check-name { font-size:.85rem; color:var(--ink); padding-right:.75rem; position:sticky; left:0; background:var(--bg); }
+  .cell { display:inline-flex; width:20px; height:20px; border-radius:4px;
+          align-items:center; justify-content:center; font-size:12px; }
+  .cell.none { background:var(--surface); border:1px dashed var(--line); }
+  .badge { display:inline-block; border-radius:4px; padding:0 .45rem; font-size:.8rem; margin-right:.5rem; }
+  details { border-left:2px solid var(--line); padding:.35rem .75rem; margin:.4rem 0; }
+  summary { cursor:pointer; }
+  details ul { margin:.4rem 0 .2rem; padding-left:1.2rem; }
+  details li { font-size:.9rem; }
+</style>
+<h1>${esc(title)}</h1>
+<p class="muted">${runs.length} recorded run${runs.length === 1 ? '' : 's'}${latest ? `, latest ${esc(latest.at)}` : ''} — pass / rot (facts changed) / error (source unreachable)</p>
+<div class="tiles">${tiles}</div>
+<h2>Timeline</h2>
+<div class="grid-wrap"><table>
+  <thead><tr><th></th>${headerCells}</tr></thead>
+  <tbody>${rows}</tbody>
+</table></div>
+<h2>Rot, errors &amp; warnings</h2>
+${log}
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stilltrue",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Your tests check your code. stilltrue checks your facts. CI checks for AI-in-the-loop apps: drift (curated facts vs live sources), golden (regression evals), verify (judge answers against sources).",
   "keywords": [
     "drift",