patina-cli 3.11.0 → 4.0.0

package/scripts/rebaseline-intake.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+// Local/private intake helper for the 2025+ rebaseline protocol.
+//
+// Reads JSONL rows, computes missing sha256 hashes from local text, and writes a
+// public manifest that strips full text whenever redistribution is not allowed.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { canRedistributeText, hashText, validateRecord } from './rebaseline-summary.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+
+export const DEFAULT_INTAKE_INPUT = 'artifacts/rebaseline-2025/intake.local.jsonl';
+export const DEFAULT_PUBLIC_OUTPUT = 'artifacts/rebaseline-2025/manifest.public.jsonl';
+export const DEFAULT_PRIVATE_OUTPUT = 'artifacts/rebaseline-2025/private/generations.private.jsonl';
+
+export function parseArgs(argv = process.argv.slice(2)) {
+  const args = {
+    input: DEFAULT_INTAKE_INPUT,
+    publicOutput: DEFAULT_PUBLIC_OUTPUT,
+    privateOutput: DEFAULT_PRIVATE_OUTPUT,
+    requireSourceReview: false,
+    dryRun: false,
+    json: false,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--input') args.input = argv[++i];
+    else if (arg === '--public-output') args.publicOutput = argv[++i];
+    else if (arg === '--private-output') args.privateOutput = argv[++i];
+    else if (arg === '--require-source-review') args.requireSourceReview = true;
+    else if (arg === '--dry-run') args.dryRun = true;
+    else if (arg === '--json') args.json = true;
+    else if (arg === '--help' || arg === '-h') args.help = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return args;
+}
+
+export function loadIntakeRows(inputPath = DEFAULT_INTAKE_INPUT) {
+  const abs = resolveRepoPath(inputPath);
+  const result = {
+    path: abs,
+    relativePath: toRepoRelative(abs),
+    rows: [],
+    errors: [],
+  };
+
+  if (!existsSync(abs)) {
+    result.errors.push(`intake input not found: ${result.relativePath}`);
+    return result;
+  }
+
+  const lines = readFileSync(abs, 'utf8').split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index++) {
+    const lineNumber = index + 1;
+    const line = lines[index].trim();
+    if (!line) continue;
+
+    try {
+      result.rows.push({ lineNumber, value: JSON.parse(line) });
+    } catch (error) {
+      result.errors.push(`line ${lineNumber}: invalid JSON (${error.message})`);
+    }
+  }
+
+  return result;
+}
+
+export function sanitizeIntakeRows(rows, options = {}) {
+  const publicRecords = [];
+  const privateRecords = [];
+  const errors = [];
+  const warnings = [];
+  const requireSourceReview = Boolean(options.requireSourceReview);
+
+  for (const row of rows) {
+    const lineNumber = row.lineNumber ?? '?';
+    const raw = row.value;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      errors.push(`line ${lineNumber}: record must be a JSON object`);
+      continue;
+    }
+
+    const record = { ...raw };
+    const label = record.sample_id ? `line ${lineNumber} (${record.sample_id})` : `line ${lineNumber}`;
+    const carriesText = typeof record.text === 'string' && record.text.length > 0;
+
+    if (carriesText) {
+      const observedHash = hashText(record.text);
+      if (record.text_hash && record.text_hash !== observedHash) {
+        errors.push(`${label}: text_hash mismatch: expected ${observedHash}`);
+      } else {
+        record.text_hash = observedHash;
+      }
+    }
+
+    const publicRecord = { ...record };
+    const textAllowed = carriesText && canRedistributeText(record.redistribution);
+    if (carriesText && !textAllowed) {
+      delete publicRecord.text;
+      privateRecords.push(record);
+    }
+    if (!canRedistributeText(record.redistribution) && !record.source_review && !record.reviewer_notes) {
+      const message = `${label}: add source_review or reviewer_notes for non-public redistribution status`;
+      if (requireSourceReview) errors.push(message);
+      else warnings.push(message);
+    }
+
+    const checked = validateRecord(publicRecord);
+    errors.push(...checked.errors.map((message) => `${label}: ${message}`));
+    warnings.push(...checked.warnings.map((message) => `${label}: ${message}`));
+
+    if (checked.errors.length === 0) publicRecords.push(checked.record);
+  }
+
+  return { publicRecords, privateRecords, errors, warnings };
+}
+
+export function processIntake(options = {}) {
+  const loaded = loadIntakeRows(options.input || DEFAULT_INTAKE_INPUT);
+  if (loaded.errors.length) {
+    return {
+      input: loaded.relativePath,
+      publicRecords: [],
+      privateRecords: [],
+      errors: loaded.errors,
+      warnings: [],
+    };
+  }
+
+  return {
+    input: loaded.relativePath,
+    ...sanitizeIntakeRows(loaded.rows, { requireSourceReview: options.requireSourceReview }),
+  };
+}
+
+export function writeIntakeOutputs(result, options = {}) {
+  if (result.errors.length) {
+    throw new Error('refusing to write invalid rebaseline intake outputs');
+  }
+
+  const publicOutput = options.publicOutput || DEFAULT_PUBLIC_OUTPUT;
+  const privateOutput = options.privateOutput || DEFAULT_PRIVATE_OUTPUT;
+  const publicPath = resolveRepoPath(publicOutput);
+  const privatePath = resolveRepoPath(privateOutput);
+
+  writeJsonl(publicPath, result.publicRecords);
+  let privateWritten = null;
+  if (result.privateRecords.length > 0) {
+    writeJsonl(privatePath, result.privateRecords);
+    privateWritten = toRepoRelative(privatePath);
+  }
+
+  return {
+    publicOutput: toRepoRelative(publicPath),
+    privateOutput: privateWritten,
+  };
+}
+
+export function renderIntakeSummary(result, written = null) {
+  const lines = [
+    '# Rebaseline Intake Summary',
+    '',
+    `- Input: \`${result.input || 'not recorded'}\``,
+    `- Public rows: ${result.publicRecords.length}`,
+    `- Private rows: ${result.privateRecords.length}`,
+    `- Validation: **${result.errors.length ? 'FAIL' : 'PASS'}**`,
+  ];
+
+  if (written) {
+    lines.push(`- Public output: \`${written.publicOutput}\``);
+    lines.push(`- Private output: ${written.privateOutput ? `\`${written.privateOutput}\`` : 'not written'}`);
+  }
+
+  if (result.errors.length) {
+    lines.push('', '## Errors', ...result.errors.map((error) => `- ${escapeMarkdown(error)}`));
+  }
+  if (result.warnings.length) {
+    lines.push('', '## Warnings', ...result.warnings.map((warning) => `- ${escapeMarkdown(warning)}`));
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function writeJsonl(path, records) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, records.map((record) => JSON.stringify(record)).join('\n') + (records.length ? '\n' : ''));
+}
+
+function resolveRepoPath(path) {
+  return resolve(REPO_ROOT, path);
+}
+
+function toRepoRelative(path) {
+  return relative(REPO_ROOT, path) || path;
+}
+
+function escapeMarkdown(value) {
+  return String(value ?? '').replace(/\|/gu, '\\|').replace(/\n/gu, ' ');
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/rebaseline-intake.mjs --input <intake.jsonl> [--public-output <manifest.jsonl>] [--private-output <private.jsonl>] [--require-source-review] [--dry-run] [--json]
+
+Computes missing text_hash values and writes a sanitized public manifest.
+Full text is kept in the public manifest only when redistribution is allowed.
+Use --require-source-review before pilot reports to fail non-public rows that
+lack source_review or reviewer_notes.
+Default input: ${DEFAULT_INTAKE_INPUT}`);
+}
+
+function main() {
+  const args = parseArgs();
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const result = processIntake({ input: args.input, requireSourceReview: args.requireSourceReview });
+  const written = !args.dryRun && result.errors.length === 0
+    ? writeIntakeOutputs(result, { publicOutput: args.publicOutput, privateOutput: args.privateOutput })
+    : null;
+
+  if (args.json) {
+    console.log(JSON.stringify({ ...result, written }, null, 2));
+  } else {
+    console.log(renderIntakeSummary(result, written));
+  }
+
+  if (result.errors.length) process.exit(1);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main();
+}

package/scripts/rebaseline-score.mjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+// Score local/private rebaseline rows with the deterministic analyzer.
+//
+// The input may contain raw text. The output is always public-safe metadata:
+// text is stripped, text_hash is preserved/computed, and only score/outcome
+// fields are added.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { analyzeText } from '../src/features/index.js';
+import { hashText, validateRecord } from './rebaseline-summary.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..');
+
+export const DEFAULT_SCORE_INPUT = 'artifacts/rebaseline-2025/private/generations.private.jsonl';
+export const DEFAULT_SCORE_OUTPUT = 'artifacts/rebaseline-2025/manifest.scored.public.jsonl';
+
+const POSITIVE_CLASSES = new Set(['ai-like', 'lightly-edited-ai', 'heavily-edited-ai']);
+
+export function parseArgs(argv = process.argv.slice(2)) {
+  const args = {
+    input: DEFAULT_SCORE_INPUT,
+    output: DEFAULT_SCORE_OUTPUT,
+    scoredAt: null,
+    json: false,
+    help: false,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--input') args.input = argv[++i];
+    else if (arg === '--output') args.output = argv[++i];
+    else if (arg === '--scored-at') args.scoredAt = argv[++i];
+    else if (arg === '--json') args.json = true;
+    else if (arg === '--help' || arg === '-h') args.help = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return args;
+}
+
+export function loadScoreRows(inputPath = DEFAULT_SCORE_INPUT) {
+  const abs = resolveRepoPath(inputPath);
+  const result = {
+    path: abs,
+    relativePath: toRepoRelative(abs),
+    rows: [],
+    errors: [],
+  };
+
+  if (!existsSync(abs)) {
+    result.errors.push(`score input not found: ${result.relativePath}`);
+    return result;
+  }
+
+  const lines = readFileSync(abs, 'utf8').split(/\r?\n/u);
+  for (let index = 0; index < lines.length; index++) {
+    const lineNumber = index + 1;
+    const line = lines[index].trim();
+    if (!line) continue;
+
+    try {
+      result.rows.push({ lineNumber, value: JSON.parse(line) });
+    } catch (error) {
+      result.errors.push(`line ${lineNumber}: invalid JSON (${error.message})`);
+    }
+  }
+
+  return result;
+}
+
+export function scoreRows(rows, options = {}) {
+  const publicRecords = [];
+  const errors = [];
+  const warnings = [];
+
+  for (const row of rows) {
+    const lineNumber = row.lineNumber ?? '?';
+    const raw = row.value;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      errors.push(`line ${lineNumber}: record must be a JSON object`);
+      continue;
+    }
+
+    const label = raw.sample_id ? `line ${lineNumber} (${raw.sample_id})` : `line ${lineNumber}`;
+    if (typeof raw.text !== 'string' || raw.text.length === 0) {
+      errors.push(`${label}: scoring requires local text`);
+      continue;
+    }
+
+    const record = { ...raw };
+    const observedHash = hashText(record.text);
+    if (record.text_hash && record.text_hash !== observedHash) {
+      errors.push(`${label}: text_hash mismatch: expected ${observedHash}`);
+      continue;
+    }
+    record.text_hash = observedHash;
+
+    const analysis = analyzeText(record.text, {
+      lang: record.language || 'en',
+      repoRoot: options.repoRoot || REPO_ROOT,
+    });
+
+    const publicRecord = { ...record };
+    delete publicRecord.text;
+
+    const checked = validateRecord(publicRecord);
+    warnings.push(...checked.warnings.map((message) => `${label}: ${message}`));
+    if (checked.errors.length) {
+      errors.push(...checked.errors.map((message) => `${label}: ${message}`));
+      continue;
+    }
+
+    const scoredRecord = {
+      ...checked.record,
+      expected_hot: POSITIVE_CLASSES.has(checked.record.class),
+      predicted_hot: Boolean(analysis.hot),
+      patina_score: scoreFromAnalysis(analysis),
+      score_review: scoreReview(analysis, options),
+    };
+
+    const finalCheck = validateRecord(scoredRecord);
+    warnings.push(...finalCheck.warnings.map((message) => `${label}: ${message}`));
+    if (finalCheck.errors.length) {
+      errors.push(...finalCheck.errors.map((message) => `${label}: ${message}`));
+      continue;
+    }
+
+    publicRecords.push(finalCheck.record);
+  }
+
+  return { publicRecords, errors, warnings };
+}
+
+export function processScore(options = {}) {
+  const loaded = loadScoreRows(options.input || DEFAULT_SCORE_INPUT);
+  if (loaded.errors.length) {
+    return {
+      input: loaded.relativePath,
+      publicRecords: [],
+      errors: loaded.errors,
+      warnings: [],
+    };
+  }
+
+  return {
+    input: loaded.relativePath,
+    ...scoreRows(loaded.rows, options),
+  };
+}
+
+export function writeScoreOutput(result, options = {}) {
+  if (result.errors.length) {
+    throw new Error('refusing to write invalid rebaseline score output');
+  }
+
+  const output = options.output || DEFAULT_SCORE_OUTPUT;
+  const outputPath = resolveRepoPath(output);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(
+    outputPath,
+    result.publicRecords.map((record) => JSON.stringify(record)).join('\n') + (result.publicRecords.length ? '\n' : '')
+  );
+
+  return { output: toRepoRelative(outputPath) };
+}
+
+export function renderScoreSummary(result, written = null) {
+  const hot = result.publicRecords.filter((record) => record.predicted_hot).length;
+  const lines = [
+    '# Rebaseline Score Summary',
+    '',
+    `- Input: \`${result.input || 'not recorded'}\``,
+    `- Public rows: ${result.publicRecords.length}`,
+    `- Predicted hot rows: ${hot}`,
+    `- Validation: **${result.errors.length ? 'FAIL' : 'PASS'}**`,
+  ];
+
+  if (written) lines.push(`- Public output: \`${written.output}\``);
+  if (result.errors.length) lines.push('', '## Errors', ...result.errors.map((error) => `- ${escapeMarkdown(error)}`));
+  if (result.warnings.length) lines.push('', '## Warnings', ...result.warnings.map((warning) => `- ${escapeMarkdown(warning)}`));
+
+  return `${lines.join('\n')}\n`;
+}
+
+function scoreFromAnalysis(analysis) {
+  const total = analysis.paragraphs.length;
+  if (!total) return 0;
+  const hot = analysis.paragraphs.filter((paragraph) => paragraph.hot).length;
+  return Math.round((hot / total) * 1000) / 10;
+}
+
+function scoreReview(analysis, options = {}) {
+  const review = {
+    scorer: 'patina deterministic analyzer',
+    paragraph_count: analysis.paragraphs.length,
+    hot_paragraph_count: analysis.paragraphs.filter((paragraph) => paragraph.hot).length,
+    trigger_counts: triggerCounts(analysis),
+  };
+  if (options.scoredAt) review.scored_at = options.scoredAt;
+  if (analysis.skipReason) review.skip_reason = analysis.skipReason;
+  return review;
+}
+
+function triggerCounts(analysis) {
+  const counts = {
+    burstiness_low: 0,
+    mattr_low: 0,
+    lexicon_hot: 0,
+    ko_diagnostics_hot: 0,
+  };
+
+  for (const paragraph of analysis.paragraphs) {
+    if (paragraph.burstiness?.band === 'low') counts.burstiness_low++;
+    if (paragraph.mattr?.band === 'low') counts.mattr_low++;
+    if (paragraph.lexicon?.hot) counts.lexicon_hot++;
+    if (paragraph.koDiagnostics?.hot) counts.ko_diagnostics_hot++;
+  }
+
+  return counts;
+}
+
+function resolveRepoPath(path) {
+  return resolve(REPO_ROOT, path);
+}
+
+function toRepoRelative(path) {
+  return relative(REPO_ROOT, path) || path;
+}
+
+function escapeMarkdown(value) {
+  return String(value ?? '').replace(/\|/gu, '\\|').replace(/\n/gu, ' ');
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/rebaseline-score.mjs --input <private.jsonl> --output <public.jsonl> [--scored-at <date>] [--json]
+
+Scores local/private rebaseline rows with the deterministic analyzer and writes
+a public-safe JSONL manifest. The output never includes raw text.
+Default input: ${DEFAULT_SCORE_INPUT}
+Default output: ${DEFAULT_SCORE_OUTPUT}`);
+}
+
+function main() {
+  const args = parseArgs();
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const result = processScore(args);
+  const written = result.errors.length === 0 ? writeScoreOutput(result, { output: args.output }) : null;
+
+  if (args.json) {
+    console.log(JSON.stringify({ ...result, written }, null, 2));
+  } else {
+    console.log(renderScoreSummary(result, written));
+  }
+
+  if (result.errors.length) process.exit(1);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main();
+}