@sun-asterisk/sungen 3.0.0-beta.83 → 3.0.0-beta.92

package/src/harness/quality-gates.ts

@@ -1,152 +0,0 @@
-/**
- * Quality gates (batch): downstream-scope + manual-oracle + negative-side-effect +
- * cross-artifact ownership + source-backed strictness.
- * Generic — read the project's own spec.md / feature text / sibling flows; no project data.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { ScenarioInfo, loadScenarios, idPrefix } from './parse';
-
-// ---------- #2 Downstream-scope ----------
-
-export interface DownstreamResult {
-  downstreamRoutes: string[];                 // success/navigation targets ≠ own route
-  underCovered: { route: string; slug: string }[]; // referenced only by a bare page-nav
-}
-
-/** Routes the spec hands off to (Navigation Flow / success), other than the screen's own route. */
-function downstreamRoutes(specText: string): string[] {
-  const ownRoute = (specText.match(/\*\*Route\*\*\s*:\s*`?(\/[^\s`]+)/) || [])[1] || '';
-  const routes = new Set<string>();
-  for (const line of specText.split('\n')) {
-    if (!/success|navigat|to \(|→/i.test(line)) continue;
-    for (const m of line.matchAll(/`?(\/[a-z][a-z0-9/_-]+)`?/gi)) {
-      const r = m[1];
-      if (r !== ownRoute && r.split('/').length > ownRoute.split('/').length - 0) routes.add(r);
-    }
-  }
-  // keep only routes that extend beyond the own route (a distinct downstream surface)
-  return [...routes].filter((r) => r !== ownRoute && (!ownRoute || r.startsWith(ownRoute + '/') || r.split('/').length >= 3));
-}
-
-export function downstreamScope(specText: string, scenarios: ScenarioInfo[]): DownstreamResult {
-  const routes = downstreamRoutes(specText);
-  const underCovered: { route: string; slug: string }[] = [];
-  for (const route of routes) {
-    const slug = (route.split('/').filter(Boolean).pop() || route).toLowerCase();
-    const refs = scenarios.filter((s) => s.haystack.includes(slug) || s.haystack.includes(route.toLowerCase()));
-    if (!refs.length) continue; // not referenced at all — out of this screen's scope entirely
-    // Substantively covered only if some scenario OPERATES on the downstream — i.e. it
-    // starts there (`is on [<downstream>]`) — not merely navigates to it as a terminal
-    // `see [<downstream>] page` assertion. The latter just proves the transition.
-    const opensOn = new RegExp(`\\bis on \\[[^\\]]*${slug}`, 'i');
-    const contentCovered = refs.some((s) => opensOn.test(s.haystack));
-    if (!contentCovered) underCovered.push({ route, slug });
-  }
-  return { downstreamRoutes: routes, underCovered };
-}
-
-// ---------- #4 Manual-oracle ----------
-
-export interface ManualOracleResult {
-  manualTotal: number;
-  insufficient: string[];   // @manual scenarios lacking setup/action/oracle
-}
-
-function blocks(featureText: string): string[] {
-  return featureText.split(/\n\s*\n/).filter((b) => /\bScenario:/.test(b));
-}
-
-export function manualOracle(featureText: string): ManualOracleResult {
-  const insufficient: string[] = [];
-  let manualTotal = 0;
-  for (const b of blocks(featureText)) {
-    if (!/@manual\b/.test(b)) continue;
-    manualTotal++;
-    const commentLines = b.split('\n').filter((l) => /^\s*#/.test(l));
-    const hasOracle = /tester verifies|oracle\s*:|requires|verify that|expected\s*:|steps?\s*:/i.test(b);
-    const hasNumberedSteps = /^\s*#?\s*\d+\.\s/m.test(b);
-    // sufficient = an oracle/steps marker, OR a substantive comment block (≥3 comment lines)
-    if (!(hasOracle || hasNumberedSteps || commentLines.length >= 3)) {
-      const name = (b.match(/Scenario:\s*(.+)/) || [])[1] || '(unnamed)';
-      insufficient.push(name.trim().slice(0, 80));
-    }
-  }
-  return { manualTotal, insufficient };
-}
-
-// ---------- #4 Negative side-effect ----------
-
-const NEG_TITLE = /\b(does not|doesn't|no second|not dispatch|not sent|without submitting|no leak|single request|exactly one|count is 1|only one request|no duplicate|not create)\b/i;
-
-/** Titles asserting an ABSENCE must prove it (count / negative / @manual+oracle), not just a happy outcome. */
-export function negativeSideEffect(scenarios: ScenarioInfo[]): string[] {
-  const flagged: string[] = [];
-  for (const s of scenarios) {
-    if (s.manual) continue;                 // @manual is a legitimate deferral (oracle checked by #4 manual-oracle)
-    if (!NEG_TITLE.test(s.name)) continue;
-    const proven = /\bcount\b|tohavecount|table with|is hidden|are hidden|not complete|message is hidden/.test(s.stepsText);
-    if (!proven) flagged.push(s.name.slice(0, 80));
-  }
-  return flagged;
-}
-
-// ---------- #7 Source-backed strictness ----------
-
-/** A scenario should trace to a source: a viewpoint ID (its own scheme), an FR id, or a
- * viewpoint item (keyword overlap). ID match is language-agnostic and primary. */
-export function sourceBacked(scenarios: ScenarioInfo[], frIds: string[], viewpointItems: string[], viewpointIds: string[], featureText: string): string[] {
-  if (!frIds.length && !viewpointItems.length && !viewpointIds.length) return []; // no contract
-  const vpIds = viewpointIds.map((s) => s.toUpperCase());
-  const itemWords = viewpointItems.map((t) => new Set((t.toLowerCase().match(/[a-z][a-z-]{4,}/g) || [])));
-  // per-scenario blocks (INCLUDING comments) so an FR cited in a comment counts as a source
-  const blockOf = new Map<string, string>();
-  for (const b of featureText.split(/\n\s*\n/)) {
-    const m = b.match(/Scenario:\s*(.+)/);
-    if (m) blockOf.set(m[1].trim().toLowerCase(), b.toLowerCase());
-  }
-  const unsourced: string[] = [];
-  for (const s of scenarios) {
-    const id = (s.vpId || s.vpCode || '').toUpperCase();
-    const mapsId = !!id && vpIds.some((v) => id === v || id.startsWith(v) || v.startsWith(idPrefix(id)));
-    const block = blockOf.get(s.name.trim().toLowerCase()) || s.haystack;
-    const citesFr = frIds.some((fid) => block.includes(fid.toLowerCase()));
-    const sWords = new Set((s.haystack.match(/[a-z][a-z-]{4,}/g) || []));
-    const mapsItem = itemWords.some((iw) => { let hits = 0; for (const w of iw) if (sWords.has(w)) hits++; return hits >= 2; });
-    if (!mapsId && !citesFr && !mapsItem) unsourced.push(s.name.slice(0, 80));
-  }
-  return unsourced;
-}
-
-// ---------- #6 Cross-artifact ownership ----------
-
-export interface OwnershipResult { duplicates: { scenario: string; flow: string }[] }
-
-/** Scenarios whose step-skeleton also appears in a sibling flow feature → duplicate ownership. */
-export function crossArtifactOwnership(screenDir: string, scenarios: ScenarioInfo[]): OwnershipResult {
-  const duplicates: { scenario: string; flow: string }[] = [];
-  // screenDir = <root>/qa/screens/<name>; flows live at <root>/qa/flows/*/features/*.feature
-  const flowsRoot = path.resolve(screenDir, '..', '..', 'flows');
-  if (!fs.existsSync(flowsRoot)) return { duplicates };
-  const bySkeleton = new Map<string, string>();
-  for (const flow of fs.readdirSync(flowsRoot)) {
-    const fdir = path.join(flowsRoot, flow, 'features');
-    if (!fs.existsSync(fdir)) continue;
-    for (const f of fs.readdirSync(fdir).filter((x) => x.endsWith('.feature'))) {
-      for (const fs2 of loadScenarios(path.join(fdir, f))) {
-        if (fs2.stepSkeleton && fs2.stepSkeleton.length > 20) bySkeleton.set(fs2.stepSkeleton, flow);
-      }
-    }
-  }
-  if (!bySkeleton.size) return { duplicates };
-  for (const s of scenarios) {
-    const flow = s.stepSkeleton && s.stepSkeleton.length > 20 ? bySkeleton.get(s.stepSkeleton) : undefined;
-    if (flow) duplicates.push({ scenario: s.name.slice(0, 70), flow });
-  }
-  return { duplicates };
-}
-
-// convenience reader
-export function readText(p: string): string {
-  return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8') : '';
-}

package/src/harness/viewpoint-ledger.ts

@@ -1,80 +0,0 @@
-/**
- * Viewpoint Atomic Coverage Ledger (harness #2).
- *
- * The project's `test-viewpoint.md` IS the coverage contract. This parses it into ATOMIC
- * items (each bullet / table row / ID-prefixed line) and reports the status of EACH —
- * covered / missing — instead of the coarse "viewpoint mentioned" signal. It is fully
- * project-driven (works on any project's viewpoint file, any domain), which is why it
- * scales where a hardcoded domain catalog does not. Advisory: it surfaces the per-item
- * gaps that inflate a "looks-covered" score; it does not fail the gate.
- */
-import * as fs from 'fs';
-import { ScenarioInfo } from './parse';
-
-export interface LedgerItem { id?: string; text: string; covered: boolean }
-
-export interface LedgerResult {
-  hasViewpoint: boolean;
-  total: number;
-  covered: number;
-  ratio: number;
-  missing: { id?: string; text: string }[];
-}
-
-const ID_RE = /\b([A-Z]{1,5}\d{0,2}(?:[.\-][A-Za-z0-9]+)*-?\d{0,3})\b/; // VP0.Title, VP7-002, MS-HP-001, TV-01
-const GENERIC = new Set(['display', 'shown', 'value', 'field', 'input', 'page', 'screen', 'button', 'link', 'text', 'check', 'verify', 'should', 'with', 'when', 'then', 'user', 'this', 'that', 'each', 'item', 'items']);
-
-/** Extract atomic checklist items from a viewpoint file (format-tolerant). */
-export function parseViewpointItems(viewpointPath: string): { id?: string; text: string }[] {
-  if (!fs.existsSync(viewpointPath)) return [];
-  const lines = fs.readFileSync(viewpointPath, 'utf-8').split('\n');
-  const items: { id?: string; text: string }[] = [];
-  let inFence = false;
-  for (const raw of lines) {
-    const line = raw.trim();
-    if (line.startsWith('```')) { inFence = !inFence; continue; }
-    if (inFence || !line) continue;
-    if (/^#{1,6}\s/.test(line)) continue;                 // markdown heading
-    let text = '';
-    const bullet = line.match(/^(?:[-*+]|\d+[.)])\s+(.*)$/);
-    if (bullet) text = bullet[1];
-    else if (line.startsWith('|')) {                       // table data row
-      if (/^\|[\s|:-]+\|?$/.test(line)) continue;           // separator
-      const cells = line.split('|').map((c) => c.trim()).filter(Boolean);
-      if (/^(vp|id|viewpoint|priority|reason|no\.?|category|item|trigger|#|pattern|applicable|notes|field|constraint|code|description|status)$/i.test(cells[0] || '')) continue; // header
-      text = cells.join(' — ');
-    } else continue;
-    text = text.replace(/[*`]/g, '').trim();
-    if (!text) continue;
-    const idM = text.match(ID_RE);
-    const id = idM && /\d/.test(idM[1]) ? idM[1] : undefined; // require a digit so prose words aren't IDs
-    const words = (text.toLowerCase().match(/[a-z][a-z-]{3,}/g) || []).filter((w) => !GENERIC.has(w));
-    if (!id && words.length < 2) continue;                 // not substantive enough to track
-    items.push({ id, text: text.slice(0, 100) });
-  }
-  return items;
-}
-
-export function viewpointLedger(viewpointPath: string, scenarios: ScenarioInfo[], featureText: string): LedgerResult {
-  const items = parseViewpointItems(viewpointPath);
-  if (!fs.existsSync(viewpointPath) || items.length === 0) {
-    return { hasViewpoint: fs.existsSync(viewpointPath), total: 0, covered: 0, ratio: 1, missing: [] };
-  }
-  const featLower = featureText.toLowerCase();
-  const missing: { id?: string; text: string }[] = [];
-  let covered = 0;
-
-  for (const item of items) {
-    let isCovered = false;
-    if (item.id && featLower.includes(item.id.toLowerCase())) isCovered = true;
-    else {
-      const words = [...new Set((item.text.toLowerCase().match(/[a-z][a-z-]{3,}/g) || []).filter((w) => !GENERIC.has(w)))];
-      const need = Math.min(2, words.length);
-      isCovered = words.length > 0 && scenarios.some((s) => words.filter((w) => s.haystack.includes(w)).length >= need);
-    }
-    if (isCovered) covered++;
-    else missing.push({ id: item.id, text: item.text });
-  }
-
-  return { hasViewpoint: true, total: items.length, covered, ratio: items.length ? covered / items.length : 1, missing };
-}