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

package/src/harness/quality-gates.ts

@@ -1,9 +1,11 @@
 /**
- * Quality gates (batch): downstream-scope (#2) + manual-oracle (#4).
- * Generic — read the project's own spec.md / feature text; no project data.
+ * 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 { ScenarioInfo } from './parse';
+import * as path from 'path';
+import { ScenarioInfo, loadScenarios, idPrefix } from './parse';
 
 // ---------- #2 Downstream-scope ----------
 
@@ -73,6 +75,77 @@ export function manualOracle(featureText: string): ManualOracleResult {
   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/sensors.ts

@@ -9,7 +9,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { parse as parseYaml } from 'yaml';
-import { ScenarioInfo, ViewpointEntry } from './parse';
+import { ScenarioInfo, ViewpointEntry, idPrefix } from './parse';
 
 // Business-critical category codes (project VP-<CAT> prefixes). Configurable later.
 const BUSINESS_CRITICAL_CATS = ['LIST', 'CART', 'PRODUCT', 'FILTER', 'CHECKOUT', 'ORDER'];
@@ -263,17 +263,23 @@ export interface TraceResult {
 
 export function traceability(scenarios: ScenarioInfo[], viewpoints: ViewpointEntry[]): TraceResult {
   const overviewIds = new Set(viewpoints.map((v) => v.id.toUpperCase()));
-  const withCode = scenarios.filter((s) => s.vpCode);
-  // A scenario maps to overview if its full VP code OR its category-derived id exists in overview.
-  const mapped = withCode.filter((s) => overviewIds.has(s.vpCode!) || [...overviewIds].some((id) => id.includes(s.category || '###')));
+  // A scenario carries an ID if it has a project-scheme leading ID (vpId) or a VP-CAT code.
+  const withCode = scenarios.filter((s) => s.vpId || s.vpCode);
+  // Maps to overview if the scenario's ID, its sequence-stripped prefix, or its VP-CAT code
+  // matches a declared viewpoint ID (format-tolerant: VP0-001↔VP0, MS-HP-001↔MS-HP-001).
+  const mapped = withCode.filter((s) => {
+    const id = (s.vpId || s.vpCode || '').toUpperCase();
+    if (overviewIds.has(id) || overviewIds.has(idPrefix(id))) return true;
+    return [...overviewIds].some((oid) => id.startsWith(oid) || oid.startsWith(idPrefix(id)) || (!!s.category && oid.includes(s.category)));
+  });
   return {
     total: scenarios.length,
     withVpCode: withCode.length,
     mappedToOverview: mapped.length,
     withVpCodeRatio: scenarios.length ? withCode.length / scenarios.length : 0,
     mappedRatio: scenarios.length ? mapped.length / scenarios.length : 0,
-    note: mapped.length < withCode.length * 0.5
-      ? 'Scenarios use ad-hoc VP-<CAT>-NNN codes not linked to viewpoint-overview ids (weak traceability — see review Gate 4).'
+    note: withCode.length && mapped.length < withCode.length * 0.5
+      ? 'Scenario IDs do not match the viewpoint-overview ids (weak traceability — re-tag to the project viewpoint IDs).'
       : 'Traceable.',
   };
 }