mirror of
https://github.com/jjbrunton/Sauci.git
synced 2026-10-31 10:19:43 +00:00
211 lines
14 KiB
JavaScript
211 lines
14 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import { readFile } from 'node:fs/promises';
|
|
|
|
const draftPath = new URL('../docs/product/question-drafts/play-safe-spicy-v1.json', import.meta.url);
|
|
const snapshotPath = new URL('../apps/supabase/catalog-snapshots/production-2026-08-28.json', import.meta.url);
|
|
const markdownPath = new URL('../docs/product/question-drafts/play-safe-spicy-v1.md', import.meta.url);
|
|
const textSourcePath = new URL('../docs/product/question-drafts/text-answer-concept-source.md', import.meta.url);
|
|
const audioSourcePath = new URL('../docs/product/question-drafts/audio-concept-source.md', import.meta.url);
|
|
const draft = JSON.parse(await readFile(draftPath, 'utf8'));
|
|
const snapshot = JSON.parse(await readFile(snapshotPath, 'utf8'));
|
|
const markdown = await readFile(markdownPath, 'utf8');
|
|
const textSource = await readFile(textSourcePath, 'utf8');
|
|
const audioSource = await readFile(audioSourcePath, 'utf8');
|
|
const errors = [];
|
|
const expect = (condition, message) => { if (!condition) errors.push(message); };
|
|
const normalize = (value) => value.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
|
|
const questionTypes = new Set(['swipe', 'text_answer', 'audio', 'photo', 'who_likely']);
|
|
const banned = /\b(?:anal|anus|asshole|bdsm|bestiality|blowjob|breath play|chok(?:e|ing)|cock|cum|dick|dildo|domination|fetish|fingering|handjob|incest|masturbat|naked|nud(?:e|ity)|oral sex|orgasm|penis|porn|public sex|sex toy|spank(?:ing)?|threesome|vagina|vibrator)\b/i;
|
|
const timeBound = /\b(?:today|tonight|right now|\bnow\b)\b/i;
|
|
const gendered = /\b(?:boyfriend|girlfriend|husband|wife|him|her|his|hers)\b/i;
|
|
const photoUnsafe = /\b(?:body part|lingerie|nude|naked|proof|skin|undress|your body)\b/i;
|
|
const artificialSuffix = /\b(?:option|response focus|voice focus|visual cue|variant|version)\s*\d+\b/i;
|
|
const malformedOrFallback = /\b(?:let your partner to|as they for|share this private idea|take the complementary role|response focus|voice focus|bolder mood|confident outfit|unfamiliar private dynamic)\b/i;
|
|
const genericOutcome = /\b(?:this match reveals whether|specific written starting point|take the complementary role|gains a personal cue for a close conversation)\b/i;
|
|
const incompleteSwipe = /^(?:a |an |the |trying |swapping )/i;
|
|
const nonActionableSwipe = /^(?:close|private|shared|more|something|anything|it|that)\b/i;
|
|
const markdownPackNames = {
|
|
'taking-the-lead': 'Taking the Lead',
|
|
'clothes-confidence': 'Clothes and Confidence',
|
|
'settings-atmosphere': 'Settings and Atmosphere',
|
|
'boundaries-check-ins': 'Boundaries and Check-ins',
|
|
'surprise-novelty': 'Surprise and Novelty',
|
|
'long-distance-desire': 'Long-distance Desire',
|
|
'giving-receiving-attention': 'Giving and Receiving Attention',
|
|
'aftercare-reconnection': 'Aftercare and Reconnection',
|
|
};
|
|
const sourcePackSlugs = {
|
|
'flirty communication': 'flirty-communication',
|
|
anticipation: 'anticipation',
|
|
'taking the lead': 'taking-the-lead',
|
|
following: 'following',
|
|
'shared control': 'shared-control',
|
|
'sensory cues': 'sensory-cues',
|
|
'private performance': 'private-performance',
|
|
'clothes and confidence': 'clothes-confidence',
|
|
'fantasy exchange': 'fantasy-exchange',
|
|
roleplay: 'roleplay',
|
|
'settings and atmosphere': 'settings-atmosphere',
|
|
'boundaries and check-ins': 'boundaries-check-ins',
|
|
'surprise and novelty': 'surprise-novelty',
|
|
'long-distance desire': 'long-distance-desire',
|
|
'giving and receiving attention': 'giving-receiving-attention',
|
|
'aftercare and reconnection': 'aftercare-reconnection',
|
|
};
|
|
const parseSource = (source, pattern, type) => [...source.matchAll(pattern)].map((match) => ({
|
|
pack_slug: sourcePackSlugs[match[1].toLowerCase()],
|
|
intensity: Number(match[2]),
|
|
text: match[3],
|
|
intended_outcome: match[4],
|
|
question_type: type,
|
|
}));
|
|
const textSourceRows = parseSource(textSource, /^\d+\. \*\*Theme:\*\* (.+?) \| \*\*Intensity:\*\* (\d)\s*\r?\n\s*\*\*Prompt:\*\* (.+?)\s*\r?\n\s*\*\*Intended outcome:\*\* (.+?)$/gm, 'text_answer');
|
|
const audioSourceRows = parseSource(audioSource, /^\d+\. Theme: (.+?) \| Intensity: (\d)\s*\r?\n\s*Prompt: (.+?)\s*\r?\n\s*Intended outcome: (.+?)$/gm, 'audio');
|
|
expect(textSourceRows.length === 100, `expected 100 text source rows, got ${textSourceRows.length}`);
|
|
expect(audioSourceRows.length === 70, `expected 70 audio source rows, got ${audioSourceRows.length}`);
|
|
const sourceKey = (row) => JSON.stringify([row.pack_slug, row.intensity, row.text, row.intended_outcome]);
|
|
|
|
expect(Array.isArray(draft.packs) && Array.isArray(draft.questions), 'draft must contain packs and questions arrays');
|
|
const questions = draft.questions ?? [];
|
|
expect(questions.length === 550, `expected 550 questions, got ${questions.length}`);
|
|
expect((draft.packs ?? []).length > 0, 'draft must contain at least one pack');
|
|
const ids = new Set();
|
|
const byId = new Map();
|
|
const typeCounts = Object.fromEntries([...questionTypes].map((type) => [type, 0]));
|
|
const intensityCounts = Object.fromEntries([1, 2, 3, 4, 5].map((level) => [level, 0]));
|
|
const packCounts = new Map();
|
|
const draftTexts = new Map();
|
|
const openingCounts = new Map();
|
|
const ngramRows = new Map();
|
|
const outcomeClusters = new Map();
|
|
const responseLeadingVerbs = new Map();
|
|
const requiredFormatOpenings = new Set(['share a photo of', 'who is more likely']);
|
|
const snapshotTexts = new Set((snapshot.tables?.questions ?? []).map((row) => normalize(row.text)));
|
|
for (const [index, question] of questions.entries()) {
|
|
const label = `question ${index + 1}`;
|
|
expect(typeof question.id === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(question.id), `${label} has invalid UUID`);
|
|
expect(!ids.has(question.id), `${label} duplicates UUID ${question.id}`);
|
|
ids.add(question.id); byId.set(question.id, question);
|
|
expect(typeof question.pack_slug === 'string' && question.pack_slug.length > 0, `${label} has no pack_slug`);
|
|
packCounts.set(question.pack_slug, (packCounts.get(question.pack_slug) ?? 0) + 1);
|
|
expect(typeof question.text === 'string' && question.text.length > 0, `${label} has no text`);
|
|
expect(!artificialSuffix.test(question.text), `${label} contains an artificial template discriminator`);
|
|
expect(!malformedOrFallback.test(question.text), `${label} contains malformed or generic fallback copy`);
|
|
expect(questionTypes.has(question.question_type), `${label} has unsupported type ${question.question_type}`);
|
|
if (questionTypes.has(question.question_type)) typeCounts[question.question_type] += 1;
|
|
expect([2, 3, 4].includes(question.intensity), `${label} has invalid intensity ${question.intensity}`);
|
|
if (Object.hasOwn(intensityCounts, question.intensity)) intensityCounts[question.intensity] += 1;
|
|
expect(question.review_status === 'draft', `${label} must be draft`);
|
|
expect(['low', 'edge'].includes(question.policy_risk), `${label} has invalid policy_risk`);
|
|
expect(typeof question.intended_outcome === 'string' && question.intended_outcome.length > 0, `${label} has no intended_outcome`);
|
|
expect(!genericOutcome.test(question.intended_outcome), `${label} has a generic fallback outcome`);
|
|
expect(question.allowed_couple_genders === null && question.target_user_genders === null && question.required_props === null, `${label} must use null targeting and props`);
|
|
const textFields = [question.text, question.partner_text, question.intended_outcome].filter(Boolean);
|
|
for (const text of textFields) {
|
|
expect(!banned.test(text), `${label} contains banned developer-authored term`);
|
|
expect(!timeBound.test(text), `${label} contains time-bound language`);
|
|
expect(!gendered.test(text), `${label} contains gendered partner language`);
|
|
expect(!text.includes('—'), `${label} contains an em dash`);
|
|
}
|
|
const normalized = normalize(question.text);
|
|
if (question.question_type === 'swipe') {
|
|
expect(!incompleteSwipe.test(question.text) && !nonActionableSwipe.test(question.text), `${label} swipe text must be a complete actionable proposal`);
|
|
if (question.partner_text !== null) {
|
|
expect(question.text !== question.partner_text, `${label} asymmetric swipe must use distinct partner wording`);
|
|
expect(!incompleteSwipe.test(question.partner_text) && !nonActionableSwipe.test(question.partner_text), `${label} asymmetric partner_text must be a complete actionable proposal`);
|
|
}
|
|
}
|
|
if (question.question_type === 'text_answer' || question.question_type === 'audio') {
|
|
const leadingVerb = normalized.split(' ')[0];
|
|
const key = `${question.question_type}:${leadingVerb}`;
|
|
responseLeadingVerbs.set(key, (responseLeadingVerbs.get(key) ?? 0) + 1);
|
|
const outcomeCluster = normalize(question.intended_outcome)
|
|
.replace(/\b(?:your|partner|the|couple|one|a|an|and|or|can|to|with|for|of|that|this|their|them|you)\b/g, ' ')
|
|
.replace(/\s+/g, ' ')
|
|
.trim();
|
|
const rows = outcomeClusters.get(outcomeCluster) ?? [];
|
|
rows.push(label);
|
|
outcomeClusters.set(outcomeCluster, rows);
|
|
}
|
|
const opening = normalized.split(' ').slice(0, 4).join(' ');
|
|
if (!requiredFormatOpenings.has(opening)) {
|
|
openingCounts.set(opening, (openingCounts.get(opening) ?? 0) + 1);
|
|
}
|
|
// An inverse row intentionally repeats its primary row's partner wording.
|
|
// Check only primary and symmetric text here; inverse swap integrity is
|
|
// checked below.
|
|
if (question.inverse_of === null) {
|
|
expect(!draftTexts.has(normalized), `${label} duplicates draft text from ${draftTexts.get(normalized)}`);
|
|
draftTexts.set(normalized, label);
|
|
const words = normalized.split(' ').filter(Boolean);
|
|
for (let start = 0; start <= words.length - 6; start += 1) {
|
|
const ngram = words.slice(start, start + 6).join(' ');
|
|
const rows = ngramRows.get(ngram) ?? [];
|
|
rows.push(label);
|
|
ngramRows.set(ngram, rows);
|
|
}
|
|
}
|
|
expect(!snapshotTexts.has(normalized), `${label} duplicates production snapshot text`);
|
|
if (question.question_type === 'audio') expect(JSON.stringify(question.config) === JSON.stringify({ max_duration_seconds: 60 }), `${label} audio config must be max_duration_seconds 60`);
|
|
if (question.question_type === 'text_answer') expect(JSON.stringify(question.config) === JSON.stringify({ max_length: 500 }), `${label} text_answer config must be max_length 500`);
|
|
if (['swipe', 'photo', 'who_likely'].includes(question.question_type)) expect(JSON.stringify(question.config) === '{}', `${label} ${question.question_type} config must be empty`);
|
|
if (question.question_type !== 'swipe') {
|
|
expect(question.partner_text === null && question.inverse_of === null, `${label} non-swipe must have null partner_text and inverse_of`);
|
|
}
|
|
if (question.question_type === 'photo') expect(!photoUnsafe.test(question.text), `${label} photo prompt is not safely clothed/object/setting based`);
|
|
}
|
|
for (const [opening, count] of openingCounts) {
|
|
expect(count <= 30, `opening template repeats ${count} times: ${opening}`);
|
|
}
|
|
for (const [ngram, rows] of ngramRows) {
|
|
expect(rows.length <= 10, `six-word phrase repeats ${rows.length} times across non-inverse rows: ${ngram}`);
|
|
}
|
|
for (const [type, sourceRows] of [['text_answer', textSourceRows], ['audio', audioSourceRows]]) {
|
|
const catalogueRows = questions.filter((question) => question.question_type === type);
|
|
const sourceKeys = new Set(sourceRows.map(sourceKey));
|
|
expect(sourceKeys.size === sourceRows.length, `${type} source contains duplicate concepts`);
|
|
expect(catalogueRows.length === sourceRows.length, `${type} source and catalogue counts differ`);
|
|
for (const question of catalogueRows) {
|
|
expect(sourceKeys.has(sourceKey(question)), `${type} row ${question.id} differs from the authored source`);
|
|
}
|
|
}
|
|
for (const [key, count] of responseLeadingVerbs) {
|
|
const [type, leadingVerb] = key.split(':');
|
|
const total = type === 'text_answer' ? 100 : 70;
|
|
expect(count <= Math.ceil(total * 0.6), `${type} leading verb "${leadingVerb}" repeats ${count} times`);
|
|
}
|
|
for (const [cluster, rows] of outcomeClusters) {
|
|
expect(cluster.length >= 16, `${rows.join(', ')} has an overly generic response outcome`);
|
|
expect(rows.length === 1, `response outcome cluster repeats across ${rows.join(', ')}`);
|
|
}
|
|
for (const [type, count] of Object.entries({ swipe: 300, text_answer: 100, audio: 70, photo: 40, who_likely: 40 })) expect(typeCounts[type] === count, `expected ${count} ${type}, got ${typeCounts[type]}`);
|
|
for (const [level, count] of Object.entries({ 1: 0, 2: 120, 3: 300, 4: 130, 5: 0 })) expect(intensityCounts[level] === count, `expected ${count} intensity ${level}, got ${intensityCounts[level]}`);
|
|
const swipes = questions.filter((question) => question.question_type === 'swipe');
|
|
const asymmetric = swipes.filter((question) => question.partner_text !== null);
|
|
const symmetric = swipes.filter((question) => question.partner_text === null);
|
|
expect(asymmetric.length === 240, `expected 240 asymmetric swipe rows, got ${asymmetric.length}`);
|
|
expect(symmetric.length === 60, `expected 60 symmetric swipe rows, got ${symmetric.length}`);
|
|
const primaries = asymmetric.filter((question) => question.inverse_of === null);
|
|
const inverses = asymmetric.filter((question) => question.inverse_of !== null);
|
|
expect(primaries.length === 120 && inverses.length === 120, `expected 120 primary and 120 inverse swipe rows, got ${primaries.length} and ${inverses.length}`);
|
|
for (const question of inverses) {
|
|
const primary = byId.get(question.inverse_of);
|
|
expect(primary?.question_type === 'swipe' && primary.inverse_of === null, `inverse ${question.id} must reference a primary swipe`);
|
|
if (primary) {
|
|
expect(question.text === primary.partner_text && question.partner_text === primary.text, `inverse ${question.id} must exactly swap text and partner_text`);
|
|
expect(question.intensity === primary.intensity && question.pack_slug === primary.pack_slug, `inverse ${question.id} must keep intensity and pack`);
|
|
}
|
|
}
|
|
for (const question of symmetric) expect(question.inverse_of === null, `symmetric swipe ${question.id} must have null inverse_of`);
|
|
expect([...packCounts.values()].every((count) => count > 0), 'every declared pack must contain questions');
|
|
for (const pack of draft.packs ?? []) {
|
|
const expectedLine = `- ${markdownPackNames[pack.slug] ?? pack.name}: ${packCounts.get(pack.slug) ?? 0} questions.`;
|
|
expect(markdown.includes(expectedLine), `markdown pack count is missing or stale: ${expectedLine}`);
|
|
}
|
|
if (errors.length) {
|
|
process.stderr.write(`Question draft validation failed (${errors.length}):\n${errors.map((error) => `- ${error}`).join('\n')}\n`);
|
|
process.exit(1);
|
|
}
|
|
process.stdout.write(`Question draft valid: ${questions.length} total; types ${JSON.stringify(typeCounts)}; intensities ${JSON.stringify(intensityCounts)}; packs ${JSON.stringify(Object.fromEntries(packCounts))}\n`);
|