@playdrop/playdrop-cli 0.16.5 → 0.16.12

package/dist/commands/review.js

@@ -14,51 +14,51 @@ const node_fs_1 = require("node:fs");
 const sharp_1 = __importDefault(require("sharp"));
 const output_1 = require("../output");
 exports.REVIEW_CRITERIA = [
-    'Gameplay / Core Loop',
-    'Depth / Replayability',
-    'Controls / Input',
-    'UX / Usability',
-    'First Time User Experience',
-    'Visuals / Art Direction',
-    'Store Listing & Metadata Accuracy',
-    'Safety / Age Rating / Compliance',
-    'Performance / Stability',
+    "Gameplay / Core Loop",
+    "Depth / Replayability",
+    "Controls / Input",
+    "UX / Usability",
+    "First Time User Experience",
+    "Visuals / Art Direction",
+    "Store Listing & Metadata Accuracy",
+    "Safety / Age Rating / Compliance",
+    "Performance / Stability",
 ];
 const STATE_OUTCOME = {
-    EXCELLENT: 'Excellent',
-    FAILED: 'Blocked',
-    GOOD: 'Good',
-    LOW_QUALITY: 'Limited',
-    PASSED: 'Passed',
+    EXCELLENT: "Excellent",
+    FAILED: "Blocked",
+    GOOD: "Good",
+    LOW_QUALITY: "Limited",
+    PASSED: "Passed",
 };
 const REVIEW_STATE_ALIASES = {
-    BLOCKED: 'FAILED',
-    EXCELLENT: 'EXCELLENT',
-    FAILED: 'FAILED',
-    GOOD: 'GOOD',
-    LIMITED: 'LOW_QUALITY',
-    LOW_QUALITY: 'LOW_QUALITY',
-    PASSED: 'PASSED',
+    BLOCKED: "FAILED",
+    EXCELLENT: "EXCELLENT",
+    FAILED: "FAILED",
+    GOOD: "GOOD",
+    LIMITED: "LOW_QUALITY",
+    LOW_QUALITY: "LOW_QUALITY",
+    PASSED: "PASSED",
 };
 function normalizeTerminalReviewState(value) {
-    const input = typeof value === 'string' ? value.trim() : '';
+    const input = typeof value === "string" ? value.trim() : "";
     const state = REVIEW_STATE_ALIASES[input.toUpperCase()];
     if (!state) {
-        throw new Error(`invalid_review_state:${input || 'missing'}:expected=Blocked|Limited|Passed|Good|Excellent`);
+        throw new Error(`invalid_review_state:${input || "missing"}:expected=Blocked|Limited|Passed|Good|Excellent`);
     }
     return state;
 }
 exports.REQUIRED_REVIEW_EVIDENCE_FILES = [
-    'first-frame.png',
-    'core.png',
-    'win.png',
-    'loss.png',
-    'composite.png',
-    'rating-card.png',
+    "first-frame.png",
+    "core.png",
+    "win.png",
+    "loss.png",
+    "composite.png",
+    "rating-card.png",
 ];
 const REVIEW_EVIDENCE_MAX_BYTES = 10 * 1024 * 1024;
 function resolveFilePath(filePath, code) {
-    const normalized = typeof filePath === 'string' ? filePath.trim() : '';
+    const normalized = typeof filePath === "string" ? filePath.trim() : "";
     if (!normalized) {
         throw new Error(code);
     }
@@ -66,7 +66,7 @@ function resolveFilePath(filePath, code) {
 }
 async function readRequiredTextFile(filePath, code) {
     const resolved = resolveFilePath(filePath, code);
-    const content = await node_fs_1.promises.readFile(resolved, 'utf8');
+    const content = await node_fs_1.promises.readFile(resolved, "utf8");
     if (!content.trim()) {
         throw new Error(code);
     }
@@ -80,17 +80,13 @@ function requireLine(text, prefix) {
     return line.slice(prefix.length).trim();
 }
 function normalizeReviewText(...values) {
-    return values
-        .join(' ')
-        .toLowerCase()
-        .replace(/\s+/g, ' ')
-        .trim();
+    return values.join(" ").toLowerCase().replace(/\s+/g, " ").trim();
 }
 function parseScores(reviewMessage) {
     const scores = {};
     for (const criterion of exports.REVIEW_CRITERIA) {
-        const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, 'm');
+        const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, "m");
         const match = reviewMessage.match(regex);
         if (!match) {
             throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
@@ -109,58 +105,77 @@ function minimumScore(scores) {
 function validateOutcomeAgainstScores(outcome, scores) {
     const average = averageScore(scores);
     const minimum = minimumScore(scores);
-    const gameplay = scores['Gameplay / Core Loop'];
-    const controls = scores['Controls / Input'];
-    const ux = scores['UX / Usability'];
-    const ftue = scores['First Time User Experience'];
-    const visuals = scores['Visuals / Art Direction'];
-    const performance = scores['Performance / Stability'];
+    const gameplay = scores["Gameplay / Core Loop"];
+    const controls = scores["Controls / Input"];
+    const ux = scores["UX / Usability"];
+    const ftue = scores["First Time User Experience"];
+    const visuals = scores["Visuals / Art Direction"];
+    const performance = scores["Performance / Stability"];
     const actual = `actual=average=${average.toFixed(2)},minimum=${minimum},gameplay=${gameplay},controls=${controls},ux=${ux},ftue=${ftue},visuals=${visuals},performance=${performance}`;
-    if (outcome === 'Excellent' && (average < 8.5 || minimum < 7 || gameplay < 8 || controls < 8 || ux < 8 || ftue < 7 || visuals < 8 || performance < 8)) {
+    if (outcome === "Excellent" &&
+        (average < 8.5 ||
+            minimum < 7 ||
+            gameplay < 8 ||
+            controls < 8 ||
+            ux < 8 ||
+            ftue < 7 ||
+            visuals < 8 ||
+            performance < 8)) {
         throw new Error(`excellent_outcome_not_supported_by_scores:requires=average>=8.5,minimum>=7,gameplay>=8,controls>=8,ux>=8,ftue>=7,visuals>=8,performance>=8:${actual}:use_good_or_lower_outcome_unless_scores_are_supported_by_evidence`);
     }
-    if (outcome === 'Good' && (average < 7.5 || minimum < 6 || gameplay < 7 || controls < 7 || ux < 7 || ftue < 6 || visuals < 7 || performance < 7)) {
+    if (outcome === "Good" &&
+        (average < 7.5 ||
+            minimum < 6 ||
+            gameplay < 7 ||
+            controls < 7 ||
+            ux < 7 ||
+            ftue < 6 ||
+            visuals < 7 ||
+            performance < 7)) {
         throw new Error(`good_outcome_not_supported_by_scores:requires=average>=7.5,minimum>=6,gameplay>=7,controls>=7,ux>=7,ftue>=6,visuals>=7,performance>=7:${actual}:use_passed_or_lower_outcome_unless_scores_are_supported_by_evidence`);
     }
-    if (outcome === 'Passed' && (average < 6 || minimum < 4 || gameplay < 5 || controls < 5 || performance < 5)) {
+    if (outcome === "Passed" && (average < 6 || minimum < 4 || gameplay < 5 || controls < 5 || performance < 5)) {
         throw new Error(`passed_outcome_not_supported_by_scores:requires=average>=6,minimum>=4,gameplay>=5,controls>=5,performance>=5:${actual}:use_low_quality_or_failed_unless_scores_are_supported_by_evidence`);
     }
 }
 function validateRequiredEvidenceLines(reviewMessage) {
-    const primaryVerb = requireLine(reviewMessage, 'Primary player verb: ');
-    const primaryEvidence = requireLine(reviewMessage, 'Primary interaction evidence: ');
-    const challengeEvidence = requireLine(reviewMessage, 'Challenge evidence: ');
-    const punchline = requireLine(reviewMessage, 'Punchline assessment: ');
-    const benchmark = requireLine(reviewMessage, 'Comparable benchmark: ');
+    const primaryVerb = requireLine(reviewMessage, "Primary player verb: ");
+    const primaryEvidence = requireLine(reviewMessage, "Primary interaction evidence: ");
+    const challengeEvidence = requireLine(reviewMessage, "Challenge evidence: ");
+    const punchline = requireLine(reviewMessage, "Punchline assessment: ");
+    const benchmark = requireLine(reviewMessage, "Comparable benchmark: ");
     if (primaryVerb.length < 3) {
-        throw new Error('primary_player_verb_too_vague');
+        throw new Error("primary_player_verb_too_vague");
     }
     if (primaryEvidence.length < 20) {
-        throw new Error('primary_interaction_evidence_too_vague');
+        throw new Error("primary_interaction_evidence_too_vague");
     }
     if (challengeEvidence.length < 20) {
-        throw new Error('challenge_evidence_too_vague');
+        throw new Error("challenge_evidence_too_vague");
     }
     if (punchline.length < 8 || punchline.length > 160) {
         throw new Error(`punchline_assessment_invalid_length: Punchline assessment length=${punchline.length}; expected 8..160 characters.`);
     }
     if (benchmark.length < 8) {
-        throw new Error('comparable_benchmark_too_vague');
+        throw new Error("comparable_benchmark_too_vague");
     }
 }
 function isNoScoreCaps(scoreCapsApplied) {
-    return scoreCapsApplied.trim().toLowerCase() === 'none';
+    return scoreCapsApplied.trim().toLowerCase() === "none";
 }
 function validateCapConsistency(input) {
     const normalizedText = normalizeReviewText(input.reviewMessage, input.creatorFeedback);
     const describesZeroChallenge = /\bzero challenge\b|\bno (?:real |meaningful )?challenge\b(?!-)|\bchallenge (?:is )?(?:absent|missing|nonexistent)\b/.test(normalizedText);
     const describesPrimaryMissing = /\bprimary (?:interaction|verb) (?:is )?(?:absent|missing|unavailable)\b/.test(normalizedText);
     if (isNoScoreCaps(input.scoreCapsApplied) && (describesZeroChallenge || describesPrimaryMissing)) {
-        const trigger = describesZeroChallenge ? 'zero_or_missing_challenge' : 'primary_interaction_missing';
+        const trigger = describesZeroChallenge ? "zero_or_missing_challenge" : "primary_interaction_missing";
         throw new Error(`missing_required_score_cap:${trigger}:score_caps_applied_must_name_the_triggered_cap_or_adjust_the_evidence_wording`);
     }
-    if (describesZeroChallenge && (['Passed', 'Good', 'Excellent'].includes(input.outcome) || input.scores['Gameplay / Core Loop'] > 3 || input.scores['Depth / Replayability'] > 3)) {
-        throw new Error('gameplay_challenge_absent_score_cap_required');
+    if (describesZeroChallenge &&
+        (["Passed", "Good", "Excellent"].includes(input.outcome) ||
+            input.scores["Gameplay / Core Loop"] > 3 ||
+            input.scores["Depth / Replayability"] > 3)) {
+        throw new Error("gameplay_challenge_absent_score_cap_required");
     }
 }
 async function assertPngFile(filePath) {
@@ -178,28 +193,28 @@ async function assertPngFile(filePath) {
 async function validateGameReviewResult(input) {
     const normalizedState = normalizeTerminalReviewState(input.reviewState);
     if (!input.reviewMessage.trim()) {
-        throw new Error('missing_review_message');
+        throw new Error("missing_review_message");
     }
-    const creatorFeedback = input.creatorFeedback ?? '';
+    const creatorFeedback = input.creatorFeedback ?? "";
     if (!creatorFeedback.trim()) {
-        throw new Error('missing_creator_feedback');
+        throw new Error("missing_creator_feedback");
     }
     if (!input.evidenceDir.trim()) {
-        throw new Error('missing_evidence_dir');
+        throw new Error("missing_evidence_dir");
     }
     const expectedOutcome = STATE_OUTCOME[normalizedState];
-    const actualOutcome = requireLine(input.reviewMessage, 'Outcome: ');
+    const actualOutcome = requireLine(input.reviewMessage, "Outcome: ");
     if (actualOutcome !== expectedOutcome) {
         throw new Error(`review_outcome_state_mismatch:${actualOutcome}:${normalizedState}`);
     }
-    const primarySurface = requireLine(input.reviewMessage, 'Primary reviewed surface: ');
-    if (!['MOBILE_PORTRAIT', 'MOBILE_LANDSCAPE', 'DESKTOP'].includes(primarySurface)) {
+    const primarySurface = requireLine(input.reviewMessage, "Primary reviewed surface: ");
+    if (!["MOBILE_PORTRAIT", "MOBILE_LANDSCAPE", "DESKTOP"].includes(primarySurface)) {
         throw new Error(`invalid_primary_reviewed_surface:${primarySurface}`);
     }
     validateRequiredEvidenceLines(input.reviewMessage);
-    const scoreCapsApplied = requireLine(input.reviewMessage, 'Score caps applied: ');
+    const scoreCapsApplied = requireLine(input.reviewMessage, "Score caps applied: ");
     if (!creatorFeedback.includes(`Reviewed surface: ${primarySurface}`)) {
-        throw new Error('creator_feedback_missing_reviewed_surface');
+        throw new Error("creator_feedback_missing_reviewed_surface");
     }
     const scores = parseScores(input.reviewMessage);
     validateOutcomeAgainstScores(actualOutcome, scores);
@@ -210,7 +225,7 @@ async function validateGameReviewResult(input) {
         scoreCapsApplied,
         scores,
     });
-    const evidenceDir = resolveFilePath(input.evidenceDir, 'missing_evidence_dir');
+    const evidenceDir = resolveFilePath(input.evidenceDir, "missing_evidence_dir");
     for (const filename of exports.REQUIRED_REVIEW_EVIDENCE_FILES) {
         await assertPngFile(node_path_1.default.join(evidenceDir, filename));
     }
@@ -225,37 +240,39 @@ async function validateGameReviewResult(input) {
 }
 async function validateReviewResultCommand(options) {
     const result = await validateGameReviewResult({
-        creatorFeedback: options.creatorFeedbackFile ? await readRequiredTextFile(options.creatorFeedbackFile, 'invalid_creator_feedback_file') : '',
+        creatorFeedback: options.creatorFeedbackFile
+            ? await readRequiredTextFile(options.creatorFeedbackFile, "invalid_creator_feedback_file")
+            : "",
         evidenceDir: options.evidenceDir,
-        reviewMessage: await readRequiredTextFile(options.messageFile, 'invalid_review_message_file'),
+        reviewMessage: await readRequiredTextFile(options.messageFile, "invalid_review_message_file"),
         reviewState: options.state,
     });
     console.log(JSON.stringify(result, null, 2));
 }
 async function resizeForComposite(filePath) {
-    const image = (0, sharp_1.default)(resolveFilePath(filePath, 'invalid_review_evidence_file'));
+    const image = (0, sharp_1.default)(resolveFilePath(filePath, "invalid_review_evidence_file"));
     const metadata = await image.metadata();
     if (!metadata.width || !metadata.height) {
-        throw new Error('invalid_review_evidence_image');
+        throw new Error("invalid_review_evidence_image");
     }
     const buffer = await image
-        .resize({ width: 540, height: 960, fit: 'inside', withoutEnlargement: true })
+        .resize({ width: 540, height: 960, fit: "inside", withoutEnlargement: true })
         .png()
         .toBuffer();
     const resizedMetadata = await (0, sharp_1.default)(buffer).metadata();
     if (!resizedMetadata.width || !resizedMetadata.height) {
-        throw new Error('invalid_review_evidence_image');
+        throw new Error("invalid_review_evidence_image");
     }
     return { buffer, width: resizedMetadata.width, height: resizedMetadata.height };
 }
 async function composeReviewEvidence(options) {
     const entries = [
-        options.core ? { label: 'core', path: options.core } : null,
-        options.win ? { label: 'win', path: options.win } : null,
-        options.loss ? { label: 'loss', path: options.loss } : null,
+        options.core ? { label: "core", path: options.core } : null,
+        options.win ? { label: "win", path: options.win } : null,
+        options.loss ? { label: "loss", path: options.loss } : null,
     ].filter((entry) => Boolean(entry));
     if (entries.length === 0) {
-        throw new Error('missing_review_evidence_images');
+        throw new Error("missing_review_evidence_images");
     }
     const images = await Promise.all(entries.map((entry) => resizeForComposite(entry.path)));
     const padding = 16;
@@ -267,7 +284,7 @@ async function composeReviewEvidence(options) {
         left += image.width + padding;
         return composite;
     });
-    const outputPath = resolveFilePath(options.out, 'missing_out');
+    const outputPath = resolveFilePath(options.out, "missing_out");
     await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
     await (0, sharp_1.default)({
         create: {
@@ -284,15 +301,11 @@ async function composeReviewEvidence(options) {
     return { outputPath, imageCount: images.length };
 }
 function escapeXml(value) {
-    return value
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;');
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function parseCriterionRating(reviewMessage, criterion) {
-    const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, 'm');
+    const escaped = criterion.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`^- ${escaped}: (10|[1-9])/10 \\| .+`, "m");
     const match = reviewMessage.match(regex);
     if (!match) {
         throw new Error(`missing_or_invalid_criterion_score:${criterion}`);
@@ -301,33 +314,33 @@ function parseCriterionRating(reviewMessage, criterion) {
 }
 function ratingColor(score) {
     if (score <= 1)
-        return '#ff3b30';
+        return "#ff3b30";
     if (score <= 4)
-        return '#ff9500';
+        return "#ff9500";
     if (score <= 6)
-        return '#ffd60a';
+        return "#ffd60a";
     if (score <= 9)
-        return '#34c759';
-    return '#bf5af2';
+        return "#34c759";
+    return "#bf5af2";
 }
 function outcomeColor(outcome) {
-    if (outcome === 'Blocked')
-        return '#ff3b30';
-    if (outcome === 'Limited')
-        return '#ff9500';
-    if (outcome === 'Passed')
-        return '#ffd60a';
-    if (outcome === 'Good')
-        return '#34c759';
-    if (outcome === 'Excellent')
-        return '#bf5af2';
-    return '#ff9500';
+    if (outcome === "Blocked")
+        return "#ff3b30";
+    if (outcome === "Limited")
+        return "#ff9500";
+    if (outcome === "Passed")
+        return "#ffd60a";
+    if (outcome === "Good")
+        return "#34c759";
+    if (outcome === "Excellent")
+        return "#bf5af2";
+    return "#ff9500";
 }
 async function createReviewRatingCard(options) {
-    const reviewMessage = await readRequiredTextFile(options.reviewMessageFile, 'invalid_review_message_file');
-    const outcome = requireLine(reviewMessage, 'Outcome: ');
-    const punchline = (options.punchline?.trim() || requireLine(reviewMessage, 'Punchline assessment: ')).slice(0, 160);
-    const title = (options.title?.trim() || 'Game review ratings').slice(0, 80);
+    const reviewMessage = await readRequiredTextFile(options.reviewMessageFile, "invalid_review_message_file");
+    const outcome = requireLine(reviewMessage, "Outcome: ");
+    const punchline = (options.punchline?.trim() || requireLine(reviewMessage, "Punchline assessment: ")).slice(0, 160);
+    const title = (options.title?.trim() || "Game review ratings").slice(0, 80);
     const rows = exports.REVIEW_CRITERIA.map((criterion, index) => {
         const score = parseCriterionRating(reviewMessage, criterion);
         const x = index < 5 ? 56 : 628;
@@ -338,7 +351,7 @@ async function createReviewRatingCard(options) {
       <text x="${x + 24}" y="${y + 42}" fill="#f5f5f7" font-size="22" font-weight="700">${escapeXml(criterion)}</text>
       <text x="${x + 448}" y="${y + 44}" fill="${ratingColor(score)}" font-size="32" font-weight="800" text-anchor="end">${score}/10</text>
     `;
-    }).join('');
+    }).join("");
     const svg = `
     <svg width="1200" height="760" xmlns="http://www.w3.org/2000/svg">
       <rect width="1200" height="760" fill="#000"/>
@@ -350,7 +363,7 @@ async function createReviewRatingCard(options) {
       <text x="600" y="708" fill="${outcomeColor(outcome)}" font-size="32" font-weight="800" text-anchor="middle">${escapeXml(punchline)}</text>
     </svg>
   `;
-    const outputPath = resolveFilePath(options.out, 'missing_out');
+    const outputPath = resolveFilePath(options.out, "missing_out");
     await node_fs_1.promises.mkdir(node_path_1.default.dirname(outputPath), { recursive: true });
     await (0, sharp_1.default)(Buffer.from(svg)).png().toFile(outputPath);
     (0, output_1.printSuccess)(`Review rating card written to ${outputPath}`);