@startsimpli/ui 0.4.65 → 0.4.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/ui",
-  "version": "0.4.65",
+  "version": "0.4.66",
   "description": "Shared UI components package for StartSimpli applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -42,8 +42,8 @@
     "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0",
-    "@startsimpli/auth": "0.4.30",
-    "@startsimpli/api": "0.5.44"
+    "@startsimpli/api": "0.5.44",
+    "@startsimpli/auth": "0.4.30"
   },
   "peerDependenciesMeta": {
     "@startsimpli/api": {

package/src/components/validation/__tests__/checks.test.ts

@@ -284,3 +284,36 @@ describe('runContentChecks — locations (768w.16.15.3 jump-to-issue)', () => {
     expect(checks.some((c) => c.status !== 'pass')).toBe(true);
   });
 });
+
+describe('source-overlap check', () => {
+  const SRC =
+    'Saudi Arabia will apply excise tax to sweetened drinks from January 2026, Gulf News reported, adding another category to a tax architecture that already captures selected products across the Gulf region.';
+
+  it('is skipped when no sourceTexts are supplied', () => {
+    expect(find(runContentChecks({ blog: 'anything' }), 'source-overlap')).toBeUndefined();
+    expect(find(runContentChecks({ blog: 'anything' }, { sourceTexts: [] }), 'source-overlap')).toBeUndefined();
+  });
+
+  it('fails when the blog copies a long verbatim run from a source', () => {
+    const c = find(
+      runContentChecks(
+        { blog: 'Saudi Arabia will apply excise tax to sweetened drinks from January 2026, Gulf News reported.' },
+        { sourceTexts: [SRC] },
+      ),
+      'source-overlap',
+    );
+    expect(c!.status).toBe('fail');
+    expect(c!.locations?.[0].field).toBe('blog');
+  });
+
+  it('passes a genuine paraphrase', () => {
+    const c = find(
+      runContentChecks(
+        { blog: 'From 2026 the Kingdom widens its sugary-drink levy, a reminder Gulf tax rules vary by market.' },
+        { sourceTexts: [SRC] },
+      ),
+      'source-overlap',
+    );
+    expect(c!.status).toBe('pass');
+  });
+});

package/src/components/validation/__tests__/overlap.test.ts

@@ -0,0 +1,58 @@
+import { verbatimOverlap, normWords } from '../overlap';
+
+const SOURCE = `Saudi Arabia will apply excise tax to sweetened drinks from January 2026,
+Gulf News reported, adding another category to a tax architecture that already
+captures selected products across the Gulf region. For businesses outside the region,
+the broader lesson is that excise tax in the GCC should be viewed as a shared framework
+with local variations that change launch economics.`;
+
+describe('normWords', () => {
+  it('lowercases, strips punctuation, collapses whitespace', () => {
+    expect(normWords('Hello,   WORLD! (2026)')).toEqual(['hello', 'world', '2026']);
+    expect(normWords('')).toEqual([]);
+    expect(normWords(null as unknown as string)).toEqual([]);
+  });
+});
+
+describe('verbatimOverlap', () => {
+  it('flags a long verbatim copy (whole sentence lifted from the source)', () => {
+    const copied = 'Saudi Arabia will apply excise tax to sweetened drinks from January 2026, Gulf News reported.';
+    const r = verbatimOverlap(copied, [SOURCE]);
+    expect(r.longestRunWords).toBeGreaterThanOrEqual(12);
+    expect(r.overlapRatio).toBeGreaterThan(0.5);
+    expect(r.sample).toContain('excise tax to sweetened drinks');
+  });
+
+  it('passes a genuine paraphrase of the same facts', () => {
+    const paraphrase =
+      'From 2026 the Kingdom broadens its excise regime to cover sugary beverages, a reminder that Gulf tax rules differ market by market.';
+    const r = verbatimOverlap(paraphrase, [SOURCE]);
+    expect(r.longestRunWords).toBeLessThan(6);
+    expect(r.overlapRatio).toBeLessThan(0.15);
+  });
+
+  it('ignores a short shared phrase (< minRun words)', () => {
+    // "excise tax" is shared but only 2 words — below the 6-word shingle.
+    const r = verbatimOverlap('Companies weighing excise tax exposure should plan ahead.', [SOURCE]);
+    expect(r.longestRunWords).toBe(0);
+  });
+
+  it('is case- and punctuation-insensitive', () => {
+    const copied = 'SHOULD BE VIEWED AS A SHARED FRAMEWORK — with local variations!!!';
+    const r = verbatimOverlap(copied, [SOURCE]);
+    expect(r.longestRunWords).toBeGreaterThanOrEqual(6);
+    expect(r.sample).toContain('shared framework');
+  });
+
+  it('returns zeros for empty candidate or no sources', () => {
+    expect(verbatimOverlap('', [SOURCE])).toEqual({ longestRunWords: 0, overlapRatio: 0, sample: '' });
+    expect(verbatimOverlap('anything here', [])).toEqual({ longestRunWords: 0, overlapRatio: 0, sample: '' });
+    expect(verbatimOverlap('anything here', [''])).toEqual({ longestRunWords: 0, overlapRatio: 0, sample: '' });
+  });
+
+  it('finds the copied span across multiple sources', () => {
+    const copied = 'a tax architecture that already captures selected products';
+    const r = verbatimOverlap(copied, ['unrelated text about camels', SOURCE]);
+    expect(r.longestRunWords).toBeGreaterThanOrEqual(7);
+  });
+});

package/src/components/validation/checks.ts

@@ -11,6 +11,7 @@
  * Keep this identical to the n8n judge's deterministic logic so client +
  * pipeline always agree. No React, no DOM — importable from a Node/LLM route.
  */
+import { verbatimOverlap } from './overlap';
 
 /** A single check's outcome. Green / amber / red, encoded redundantly in the UI. */
 export type CheckStatus = 'pass' | 'warn' | 'fail';
@@ -90,6 +91,18 @@ export interface ContentChecksConfig {
   hypeWords?: string[];
   /** Approved source hosts (no `www.`). REQUIRED to run the source check. */
   approvedHosts?: string[];
+  /**
+   * The cited source articles' TEXT. REQUIRED to run the verbatim-overlap check —
+   * the guardrail against copying too much from a source. Omit it (or pass []) and
+   * the check is skipped (nothing to compare against).
+   */
+  sourceTexts?: string[];
+  /** Longest verbatim run (words) that FAILS the overlap check (default 15). */
+  overlapFailRun?: number;
+  /** Longest verbatim run (words) that WARNS (default 8). */
+  overlapWarnRun?: number;
+  /** Copied fraction (0–1) that FAILS regardless of run length (default 0.25). */
+  overlapFailRatio?: number;
 }
 
 /**
@@ -186,6 +199,10 @@ export function runContentChecks(fields: ContentFields, config: ContentChecksCon
     requireLink = true,
     hypeWords = DEFAULT_HYPE_WORDS,
     approvedHosts,
+    sourceTexts,
+    overlapFailRun = 15,
+    overlapWarnRun = 8,
+    overlapFailRatio = 0.25,
   } = config;
 
   // Word-count bands.
@@ -297,6 +314,51 @@ export function runContentChecks(fields: ContentFields, config: ContentChecksCon
     }
   }
 
+  // Verbatim overlap — the anti-plagiarism guardrail. Only when the caller supplied
+  // the cited source article TEXT. Scans blog + linkedin against the sources and
+  // reports the WORST offender (longest copied run / highest copied fraction).
+  if (sourceTexts !== undefined && sourceTexts.length > 0) {
+    const targets: Array<[keyof ContentFields, string | undefined]> = [
+      ['blog', fields.blog],
+      ['linkedin', fields.linkedin],
+    ];
+    let worstRun = 0;
+    let worstRatio = 0;
+    let worstField: keyof ContentFields | null = null;
+    let worstSample = '';
+    for (const [field, text] of targets) {
+      if (typeof text !== 'string' || !text.trim()) continue;
+      if (worstField === null) worstField = field; // at least one field present → emit (even a clean pass)
+      const o = verbatimOverlap(text, sourceTexts);
+      if (o.longestRunWords > worstRun) {
+        worstRun = o.longestRunWords;
+        worstField = field;
+        worstSample = o.sample;
+      }
+      if (o.overlapRatio > worstRatio) worstRatio = o.overlapRatio;
+    }
+    if (worstField !== null) {
+      const status: CheckStatus =
+        worstRun >= overlapFailRun || worstRatio >= overlapFailRatio
+          ? 'fail'
+          : worstRun >= overlapWarnRun
+            ? 'warn'
+            : 'pass';
+      checks.push({
+        id: 'source-overlap',
+        label: 'Original wording (not copied from sources)',
+        status,
+        detail:
+          status === 'pass'
+            ? `${worstRun}-word max run`
+            : `copies ${worstRun} consecutive words (${Math.round(worstRatio * 100)}% overlap)`,
+        ...(status !== 'pass'
+          ? { locations: [{ field: worstField, matches: worstSample ? [worstSample] : undefined }] }
+          : {}),
+      });
+    }
+  }
+
   return checks;
 }
 

package/src/components/validation/index.ts

@@ -28,6 +28,8 @@ export {
   type Band,
 } from './checks';
 
+export { verbatimOverlap, normWords, type OverlapResult } from './overlap';
+
 export { ValidationChecklist } from './ValidationChecklist';
 export type {
   ValidationChecklistProps,

package/src/components/validation/overlap.ts

@@ -0,0 +1,91 @@
+/**
+ * Verbatim-overlap detector (bd startsim-768w.18.16.1).
+ *
+ * Measures how much of a generated passage is copied VERBATIM from its source
+ * articles — the guardrail against plagiarism / SEO duplicate-content now that the
+ * writer is fed real article text. Pure + framework-free so it unit-tests in node.
+ *
+ * Method: word-shingle coverage. Both sides are normalised (lowercased, punctuation
+ * stripped, whitespace collapsed) to words; every `minRun`-word shingle of the
+ * sources goes in a set; each candidate position covered by an in-source shingle is
+ * marked "copied". From that we report the LONGEST consecutive copied run (words)
+ * and the fraction of the candidate that is copied. Short shared phrases (< minRun
+ * words) are deliberately invisible — quoting a handful of words is fine.
+ */
+
+export interface OverlapResult {
+  /** Longest run of consecutive candidate words copied verbatim from a source. */
+  longestRunWords: number;
+  /** Fraction (0–1) of candidate words that sit inside a copied run. */
+  overlapRatio: number;
+  /** The longest copied span (normalised words), for a human detail. '' when none. */
+  sample: string;
+}
+
+/** Lowercase, strip punctuation, collapse whitespace → word list. */
+export function normWords(s: string): string[] {
+  return String(s ?? '')
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+/**
+ * Verbatim overlap of `candidate` against `sources`. `minRun` (default 6) is the
+ * shingle size — the shortest copied run that counts (so ≤5-word coincidences /
+ * short quotes are ignored). Returns zeros for empty candidate or no sources.
+ */
+export function verbatimOverlap(
+  candidate: string,
+  sources: string[],
+  minRun = 6,
+): OverlapResult {
+  const cand = normWords(candidate);
+  const n = cand.length;
+  const empty: OverlapResult = { longestRunWords: 0, overlapRatio: 0, sample: '' };
+  if (n === 0 || minRun < 1) return empty;
+
+  const shingles = new Set<string>();
+  for (const src of sources ?? []) {
+    const w = normWords(src);
+    for (let i = 0; i + minRun <= w.length; i++) {
+      shingles.add(w.slice(i, i + minRun).join(' '));
+    }
+  }
+  if (shingles.size === 0) return empty;
+
+  const covered = new Array<boolean>(n).fill(false);
+  for (let i = 0; i + minRun <= n; i++) {
+    if (shingles.has(cand.slice(i, i + minRun).join(' '))) {
+      for (let j = i; j < i + minRun; j++) covered[j] = true;
+    }
+  }
+
+  let longest = 0;
+  let coveredCount = 0;
+  let cur = 0;
+  let curStart = 0;
+  let bestStart = -1;
+  let bestEnd = -1;
+  for (let i = 0; i < n; i++) {
+    if (covered[i]) {
+      coveredCount++;
+      if (cur === 0) curStart = i;
+      cur++;
+      if (cur > longest) {
+        longest = cur;
+        bestStart = curStart;
+        bestEnd = i;
+      }
+    } else {
+      cur = 0;
+    }
+  }
+
+  return {
+    longestRunWords: longest,
+    overlapRatio: coveredCount / n,
+    sample: longest > 0 ? cand.slice(bestStart, bestEnd + 1).join(' ') : '',
+  };
+}