@sun-asterisk/sungen 2.6.8 → 2.6.10

package/src/dashboard/history-store.ts

@@ -1,7 +1,8 @@
 /**
- * Persist dashboard snapshots under qa/dashboard/history/ and prune to a fixed
- * max count (oldest by mtime are deleted). Used by `sungen dashboard` to
- * accumulate runs for Trends / Compare views.
+ * Persist dashboard snapshots under qa/dashboard/history/. Files are never
+ * deleted — `max` only controls how many are *included* in dashboard stats /
+ * payload. Older files beyond `max` are retained on disk as `archived` so
+ * trends / compare data is recoverable.
  */
 
 import * as fs from 'fs';
@@ -12,8 +13,9 @@ export const DEFAULT_MAX_HISTORY = 20;
 
 export interface HistoryWriteResult {
   written: string;                     // absolute path written
-  pruned: string[];                    // absolute paths removed
-  retained: string[];                  // absolute paths still on disk (newest → oldest)
+  total: number;                       // total files on disk (after write)
+  included: string[];                  // newest → oldest, capped at max
+  archived: string[];                  // files beyond max, still on disk
 }
 
 export function historyDir(cwd: string): string {
@@ -21,8 +23,8 @@ export function historyDir(cwd: string): string {
 }
 
 /**
- * Write `snapshot` as <runId>.json and prune older files until at most `max`
- * files remain. Files are sorted by mtime so manual edits (rare) still work.
+ * Write `snapshot` as <runId>.json. Never deletes existing files; `max` only
+ * partitions the on-disk list into `included` (newest N) vs `archived`.
  */
 export function writeSnapshotToHistory(
   cwd: string,
@@ -36,10 +38,10 @@ export function writeSnapshotToHistory(
   const target = path.join(dir, filename);
   fs.writeFileSync(target, JSON.stringify(snapshot, null, 2), 'utf-8');
 
-  const pruned = pruneHistory(dir, max);
-
-  const retained = listHistoryFiles(dir);
-  return { written: target, pruned, retained };
+  const all = listHistoryFiles(dir);          // newest first
+  const included = all.slice(0, max);
+  const archived = all.slice(max);
+  return { written: target, total: all.length, included, archived };
 }
 
 /**
@@ -54,11 +56,17 @@ export function listHistoryFiles(dir: string): string[] {
 }
 
 /**
- * Read every history JSON, oldest → newest. Skips files that fail to parse.
+ * Read history JSONs, oldest → newest. When `limit` is provided, only the
+ * newest `limit` files are loaded (older ones stay on disk but are skipped).
+ * Skips files that fail to parse.
  */
-export function readHistory(cwd: string): DashboardSnapshot[] {
+export function readHistory(cwd: string, limit?: number): DashboardSnapshot[] {
   const dir = historyDir(cwd);
-  const files = listHistoryFiles(dir).reverse(); // oldest → newest
+  let files = listHistoryFiles(dir);          // newest first
+  if (typeof limit === 'number' && limit >= 0) {
+    files = files.slice(0, limit);
+  }
+  files = files.reverse();                    // oldest → newest
   const out: DashboardSnapshot[] = [];
   for (const f of files) {
     try {
@@ -70,17 +78,3 @@ export function readHistory(cwd: string): DashboardSnapshot[] {
   }
   return out;
 }
-
-/**
- * Delete oldest files in `dir` until at most `max` remain.
- * Returns the absolute paths removed.
- */
-function pruneHistory(dir: string, max: number): string[] {
-  const files = listHistoryFiles(dir);              // newest first
-  if (files.length <= max) return [];
-  const toRemove = files.slice(max);
-  for (const f of toRemove) {
-    try { fs.unlinkSync(f); } catch { /* ignore */ }
-  }
-  return toRemove;
-}

package/src/dashboard/html-renderer.ts

@@ -42,8 +42,12 @@ export function resolveTemplatePath(): string {
   );
 }
 
-export function buildPayload(cwd: string, current: DashboardSnapshot): DashboardPayload {
-  const all = readHistory(cwd);
+export function buildPayload(
+  cwd: string,
+  current: DashboardSnapshot,
+  historyLimit?: number,
+): DashboardPayload {
+  const all = readHistory(cwd, historyLimit);
   // Exclude `current` from history if it's been written there already.
   const history = all.filter((s) => s.runId !== current.runId);
   return { current, history };

package/src/dashboard/snapshot-builder.ts

@@ -14,6 +14,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
+import { parse as parseYaml } from 'yaml';
 import { parseFeatureMetadata } from '../exporters/feature-parser';
 import { parseSpecFile } from '../exporters/spec-parser';
 import { loadTestData } from '../exporters/test-data-resolver';
@@ -99,11 +100,20 @@ function buildOneScreen(
   const label = target.isFlow ? `flow/${target.name}` : target.name;
   const specLink = fs.existsSync(specMdFile) ? path.relative(cwd, specMdFile) : undefined;
 
+  // Screens declare their URL inline in the .feature ("Path: /awards"). Flows
+  // don't have one there, so fall back to the first `type: 'page'` entry in
+  // the flow's selectors YAML — that's where the entry point is recorded.
+  let featurePath = feature.featurePath;
+  if (!featurePath && target.isFlow) {
+    const selectorsFile = path.join(base, 'selectors', `${target.name}.yaml`);
+    featurePath = readPagePathFromSelectors(selectorsFile);
+  }
+
   return buildScreenSnapshot({
     screen: label,
     isFlow: target.isFlow,
     featureName: feature.featureName,
-    featurePath: feature.featurePath,
+    featurePath,
     specLink,
     merged,
     testData,
@@ -125,7 +135,7 @@ function aggregateSummary(screens: ScreenSnapshot[]): AggregateSummary {
     na: 0,
     notCompiled: 0,
     passRate: 0,
-    byPriority: { Critical: 0, High: 0, Normal: 0, Low: 0 },
+    byPriority: { High: 0, Normal: 0, Low: 0 },
     byCategory: { Accessing: 0, GUI: 0, Function: 0 },
     byType: { Auto: 0, Manual: 0, 'Not compiled': 0 },
   };
@@ -269,5 +279,29 @@ function collectEnvironment(cwd: string, env: EnvironmentInfo) {
   };
 }
 
+/**
+ * Read the entry-point path for a flow from its selectors YAML. We pick the
+ * first selector whose `type` is `page` — that's the convention sungen uses
+ * for the page-selector block in flow YAML files. Returns undefined when the
+ * file is missing or has no page entry.
+ */
+function readPagePathFromSelectors(selectorsFile: string): string | undefined {
+  if (!fs.existsSync(selectorsFile)) return undefined;
+  try {
+    const raw = fs.readFileSync(selectorsFile, 'utf-8');
+    const parsed = parseYaml(raw);
+    if (!parsed || typeof parsed !== 'object') return undefined;
+    for (const value of Object.values(parsed as Record<string, unknown>)) {
+      if (value && typeof value === 'object' && (value as { type?: string }).type === 'page') {
+        const v = (value as { value?: unknown }).value;
+        if (typeof v === 'string' && v.length > 0) return v;
+      }
+    }
+  } catch {
+    // Malformed YAML — fall through to undefined.
+  }
+  return undefined;
+}
+
 // Helper for ScenarioSnapshot tree filters in UI (re-exported for callers)
 export type { ScenarioSnapshot };