audrey 1.1.2 → 1.2.0

package/scripts/verify-arxiv-source.mjs

@@ -1,224 +0,0 @@
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { dirname, join, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { validateSchema } from '../benchmarks/validate-guardbench-artifacts.mjs';
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const DEFAULT_DIR = 'docs/paper/output/arxiv';
-const DEFAULT_SCHEMA = 'docs/paper/arxiv-source.schema.json';
-const REQUIRED_FILES = ['main.tex', 'references.bib', 'README-arxiv.txt'];
-const SEEDED_SECRET = 'sk-guardbench-secret-0000000000000000000000000000';
-
-function fromRoot(path) {
-  return resolve(ROOT, path);
-}
-
-function readJson(path) {
-  return JSON.parse(readFileSync(path, 'utf-8'));
-}
-
-function sha256File(path) {
-  return createHash('sha256').update(readFileSync(path)).digest('hex');
-}
-
-function countBibEntries(text) {
-  return [...text.matchAll(/@\w+\s*\{/g)].length;
-}
-
-function walkFiles(dir, root = dir) {
-  return readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) return walkFiles(path, root);
-    return relative(root, path).replaceAll('\\', '/');
-  });
-}
-
-function checkSourceHash(label, sourcePath, expectedHash, failures) {
-  if (!sourcePath || !expectedHash) return;
-  const absolute = fromRoot(sourcePath);
-  if (!existsSync(absolute)) {
-    failures.push(`arxiv-manifest.json: missing source file for ${label}: ${sourcePath}`);
-    return;
-  }
-  if (expectedHash !== sha256File(absolute))
-    failures.push(`arxiv-manifest.json: ${label} hash is stale`);
-}
-
-function parseArgs(argv = process.argv.slice(2)) {
-  const args = {
-    dir: DEFAULT_DIR,
-    schema: DEFAULT_SCHEMA,
-    json: false,
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const token = argv[i];
-    if ((token === '--dir' || token === '--source-dir') && argv[i + 1]) args.dir = argv[++i];
-    else if (token === '--schema' && argv[i + 1]) args.schema = argv[++i];
-    else if (token === '--json') args.json = true;
-    else if (token === '--help' || token === '-h') args.help = true;
-    else throw new Error(`Unknown argument: ${token}`);
-  }
-  return args;
-}
-
-function usage() {
-  return `Usage: node scripts/verify-arxiv-source.mjs [options]
-
-Options:
-  --dir <path>     arXiv source directory. Default: ${DEFAULT_DIR}.
-  --schema <path>  arXiv source manifest schema. Default: ${DEFAULT_SCHEMA}.
-  --json           Print the machine-readable verification report.
-`;
-}
-
-export function verifyArxivSourcePackage(options = {}) {
-  const dir = fromRoot(options.dir ?? DEFAULT_DIR);
-  const schemaPath = fromRoot(options.schema ?? DEFAULT_SCHEMA);
-  const manifestPath = join(dir, 'arxiv-manifest.json');
-  const failures = [];
-  let manifest;
-
-  try {
-    manifest = readJson(manifestPath);
-  } catch (error) {
-    return {
-      ok: false,
-      dir,
-      files: [],
-      citationCount: 0,
-      bibEntries: 0,
-      failures: [`arxiv-manifest.json: ${error.message}`],
-    };
-  }
-
-  try {
-    failures.push(...validateSchema(manifest, readJson(schemaPath), 'audrey-arxiv-source'));
-  } catch (error) {
-    failures.push(`schema: ${error.message}`);
-  }
-
-  const listed = new Map((manifest.files ?? []).map(file => [file.path, file]));
-  for (const file of REQUIRED_FILES) {
-    if (!listed.has(file))
-      failures.push(`arxiv-manifest.json: missing required file record ${file}`);
-  }
-  if (listed.has('arxiv-manifest.json'))
-    failures.push('arxiv-manifest.json: must not include a self-hash file record');
-  checkSourceHash(
-    'sourceMarkdown',
-    manifest.sourceMarkdown,
-    manifest.sourceHashes?.sourceMarkdown,
-    failures,
-  );
-  checkSourceHash(
-    'publicationPack',
-    manifest.publicationPack,
-    manifest.sourceHashes?.publicationPack,
-    failures,
-  );
-  checkSourceHash(
-    'referencesBib',
-    'docs/paper/references.bib',
-    manifest.sourceHashes?.referencesBib,
-    failures,
-  );
-
-  for (const [file, record] of listed) {
-    const path = join(dir, file);
-    if (!existsSync(path)) {
-      failures.push(`${file}: listed in manifest but missing from package`);
-      continue;
-    }
-    const bytes = readFileSync(path).byteLength;
-    if (record.bytes !== bytes) failures.push(`${file}: byte length mismatch`);
-    if (record.sha256 !== sha256File(path)) failures.push(`${file}: sha256 mismatch`);
-    if (record.source && record.source !== 'generated') {
-      const sourcePath = fromRoot(record.source);
-      if (existsSync(sourcePath)) {
-        const sourceSha = sha256File(sourcePath);
-        if (record.source === 'docs/paper/references.bib' && sourceSha !== record.sha256) {
-          failures.push(`${file}: source bibliography has changed since arXiv package creation`);
-        }
-      }
-    }
-  }
-
-  const actualFiles = walkFiles(dir)
-    .filter(file => file !== 'arxiv-manifest.json')
-    .sort();
-  const listedFiles = [...listed.keys()].sort();
-  const listedSet = new Set(listedFiles);
-  for (const file of actualFiles) {
-    if (!listedSet.has(file))
-      failures.push(`${file}: present in package but missing from manifest`);
-  }
-
-  const mainPath = join(dir, 'main.tex');
-  const bibPath = join(dir, 'references.bib');
-  const main = existsSync(mainPath) ? readFileSync(mainPath, 'utf-8') : '';
-  const bib = existsSync(bibPath) ? readFileSync(bibPath, 'utf-8') : '';
-  const citationCount = [...main.matchAll(/\\cite\{([^}]+)\}/g)].length;
-  const citedIds = new Set(
-    [...main.matchAll(/\\cite\{([^}]+)\}/g)].flatMap(match =>
-      match[1].split(',').map(id => id.trim()),
-    ),
-  );
-  const bibIds = new Set([...bib.matchAll(/@\w+\s*\{\s*([^,\s]+)/g)].map(match => match[1].trim()));
-  const bibEntries = countBibEntries(bib);
-
-  if (!main.includes('\\documentclass')) failures.push('main.tex: missing documentclass');
-  if (!main.includes('\\begin{abstract}')) failures.push('main.tex: missing abstract');
-  if (!main.includes('\\bibliography{references}'))
-    failures.push('main.tex: missing bibliography command');
-  if (main.includes('[@')) failures.push('main.tex: contains unconverted Markdown citation syntax');
-  if (/^#{1,6}\s/m.test(main))
-    failures.push('main.tex: contains unconverted Markdown heading syntax');
-  if (main.includes(SEEDED_SECRET)) failures.push('main.tex: contains seeded raw secret');
-  if (/([A-Z]:\\|file:\/\/|C:\\Users\\|B:\\Projects\\)/i.test(main))
-    failures.push('main.tex: contains a local absolute path');
-  if (citationCount < 1) failures.push('main.tex: expected at least one citation');
-  if (bibEntries !== 21) failures.push(`references.bib: expected 21 entries, found ${bibEntries}`);
-  for (const id of citedIds) {
-    if (!bibIds.has(id)) failures.push(`main.tex: cites missing bibliography id ${id}`);
-  }
-  if (manifest.tex?.citationCount !== citationCount)
-    failures.push('arxiv-manifest.json: citation count is stale');
-  if (manifest.tex?.bibEntryCount !== bibEntries)
-    failures.push('arxiv-manifest.json: bibliography count is stale');
-
-  return {
-    ok: failures.length === 0,
-    dir,
-    manifestPath,
-    files: listedFiles,
-    citationCount,
-    bibEntries,
-    failures,
-  };
-}
-
-function main() {
-  const args = parseArgs();
-  if (args.help) {
-    console.log(usage());
-    return;
-  }
-  const report = verifyArxivSourcePackage(args);
-  if (args.json) console.log(JSON.stringify(report, null, 2));
-  else if (report.ok) console.log(`arXiv source package verification passed: ${report.dir}`);
-  else {
-    console.error('arXiv source package verification failed:');
-    for (const failure of report.failures) console.error(`- ${failure}`);
-  }
-  if (!report.ok) process.exit(1);
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  try {
-    main();
-  } catch (error) {
-    console.error(error.stack ?? error.message);
-    process.exit(1);
-  }
-}

package/scripts/verify-browser-launch-plan.mjs

@@ -1,254 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { publicPath } from '../benchmarks/public-paths.mjs';
-import { validateSchema } from '../benchmarks/validate-guardbench-artifacts.mjs';
-import { verifyPublicationPack } from './verify-publication-pack.mjs';
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const DEFAULT_PLAN = 'docs/paper/browser-launch-plan.json';
-const DEFAULT_SCHEMA = 'docs/paper/browser-launch-plan.schema.json';
-const REQUIRED_TARGETS = [
-  'arxiv-preprint',
-  'hacker-news-show',
-  'reddit-discussion',
-  'x-launch-thread',
-  'linkedin-launch-post',
-];
-const REQUIRED_PREFLIGHT_COMMANDS = [
-  'npm run release:gate:paper',
-  'npm run paper:publication-pack',
-  'npm run paper:bundle:verify',
-  'npm run paper:launch-plan',
-];
-const ALLOWED_HOSTS = {
-  arxiv: ['arxiv.org'],
-  'hacker-news': ['news.ycombinator.com'],
-  reddit: ['www.reddit.com', 'reddit.com'],
-  x: ['twitter.com', 'x.com'],
-  linkedin: ['www.linkedin.com', 'linkedin.com'],
-};
-const PLATFORM_ENTRY_RULES = {
-  arxiv: new Set(['arxiv-title', 'arxiv-abstract']),
-  'hacker-news': new Set(['hacker-news-title', 'hacker-news-comment']),
-  reddit: new Set(['reddit-title', 'reddit-body']),
-  x: new Set(['x-post-1', 'x-post-2']),
-  linkedin: new Set(['linkedin-post']),
-};
-
-function fromRoot(path) {
-  return resolve(ROOT, path);
-}
-
-function readText(path) {
-  const absolute = fromRoot(path);
-  if (!existsSync(absolute)) throw new Error(`Missing required file: ${path}`);
-  return readFileSync(absolute, 'utf-8');
-}
-
-function readJson(path) {
-  return JSON.parse(readText(path));
-}
-
-function parseArgs(argv = process.argv.slice(2)) {
-  const args = {
-    plan: DEFAULT_PLAN,
-    schema: DEFAULT_SCHEMA,
-    json: false,
-  };
-
-  for (let i = 0; i < argv.length; i++) {
-    const token = argv[i];
-    if (token === '--plan' && argv[i + 1]) args.plan = argv[++i];
-    else if (token === '--schema' && argv[i + 1]) args.schema = argv[++i];
-    else if (token === '--json') args.json = true;
-    else if (token === '--help' || token === '-h') args.help = true;
-    else throw new Error(`Unknown argument: ${token}`);
-  }
-
-  return args;
-}
-
-function usage() {
-  return `Usage: node scripts/verify-browser-launch-plan.mjs [options]
-
-Options:
-  --plan <path>    Browser launch plan JSON. Default: ${DEFAULT_PLAN}.
-  --schema <path>  Browser launch plan schema. Default: ${DEFAULT_SCHEMA}.
-  --json           Print the machine-readable verification report.
-`;
-}
-
-function isAllowedHost(platform, value) {
-  try {
-    const url = new URL(value);
-    return (ALLOWED_HOSTS[platform] ?? []).includes(url.hostname);
-  } catch {
-    return false;
-  }
-}
-
-function hasPendingBoundary(text) {
-  return /\b(pending|not claim|not claimed|does not report|remain pending|live evidence|strict evidence)\b/i.test(
-    text,
-  );
-}
-
-function validateTarget(target, entryMap, sourceIds) {
-  const failures = [];
-  const allowedEntries = PLATFORM_ENTRY_RULES[target.platform] ?? new Set();
-  const targetEntries = [];
-
-  if (!isAllowedHost(target.platform, target.url)) {
-    failures.push(`${target.id}: URL host is not allowed for ${target.platform}`);
-  }
-  for (const entryId of target.contentEntryIds) {
-    const entry = entryMap.get(entryId);
-    if (!entry) {
-      failures.push(`${target.id}: unknown publication-pack entry ${entryId}`);
-      continue;
-    }
-    if (entry.platform !== target.platform) {
-      failures.push(
-        `${target.id}: entry ${entryId} belongs to ${entry.platform}, not ${target.platform}`,
-      );
-    }
-    if (!allowedEntries.has(entryId)) {
-      failures.push(`${target.id}: entry ${entryId} is not approved for ${target.platform}`);
-    }
-    if (entry.text.length > entry.maxChars) {
-      failures.push(`${target.id}: entry ${entryId} exceeds maxChars`);
-    }
-    if (/\b(Mem0|Zep)\b/.test(entry.text) && !hasPendingBoundary(entry.text)) {
-      failures.push(
-        `${target.id}: entry ${entryId} mentions Mem0/Zep without pending boundary language`,
-      );
-    }
-    targetEntries.push(entry);
-  }
-  for (const sourceId of target.sourceRefs) {
-    if (!sourceIds.has(sourceId)) failures.push(`${target.id}: unknown sourceRef ${sourceId}`);
-  }
-  for (const artifact of target.artifactRefs) {
-    if (!existsSync(fromRoot(artifact)))
-      failures.push(`${target.id}: missing artifactRef ${artifact}`);
-  }
-  if (target.platform === 'reddit' && target.manualRuleCheckRequired !== true) {
-    failures.push(`${target.id}: Reddit target must require a manual subreddit rule check`);
-  }
-  if (target.platform === 'hacker-news' && target.manualRuleCheckRequired !== true) {
-    failures.push(`${target.id}: Hacker News target must require a manual guideline check`);
-  }
-  if (target.platform === 'arxiv' && target.manualRuleCheckRequired !== true) {
-    failures.push(`${target.id}: arXiv target must require a manual category/metadata check`);
-  }
-  if (!target.humanRequired)
-    failures.push(`${target.id}: browser launch targets must require a human operator`);
-  if (!target.authRequired)
-    failures.push(`${target.id}: browser launch targets must require authenticated account review`);
-  if (target.operatorChecks.length < 2)
-    failures.push(`${target.id}: operator checklist is too thin`);
-  if (target.postSubmitChecks.length < 1) failures.push(`${target.id}: missing post-submit checks`);
-  if (
-    target.platform === 'x' &&
-    target.status === 'blocked-until-artifact-url' &&
-    !targetEntries.some(entry => entry.requiresArtifactUrl === true)
-  ) {
-    failures.push(
-      `${target.id}: X artifact-url launch target must include a publication entry with reserved URL budget`,
-    );
-  }
-
-  return failures;
-}
-
-export async function verifyBrowserLaunchPlan(options = {}) {
-  const plan = readJson(options.plan ?? DEFAULT_PLAN);
-  const schema = readJson(options.schema ?? DEFAULT_SCHEMA);
-  const publicationReport = await verifyPublicationPack({ pack: plan.publicationPack });
-  const publicationPack = readJson(plan.publicationPack);
-  const entryMap = new Map((publicationPack.entries ?? []).map(entry => [entry.id, entry]));
-  const sourceIds = new Set((plan.sources ?? []).map(source => source.id));
-  const ids = new Set();
-  const targetReports = [];
-  const failures = [
-    ...validateSchema(plan, schema, 'audrey-browser-launch-plan').map(
-      failure => `browser launch plan schema: ${failure}`,
-    ),
-  ];
-
-  if (!publicationReport.ok) {
-    failures.push(...publicationReport.failures.map(failure => `publication pack: ${failure}`));
-  }
-  if (plan.publicationPack !== 'docs/paper/publication-pack.json') {
-    failures.push('browser launch plan must point at docs/paper/publication-pack.json');
-  }
-  for (const command of REQUIRED_PREFLIGHT_COMMANDS) {
-    if (!(plan.preflightCommands ?? []).includes(command))
-      failures.push(`Missing browser-launch preflight command: ${command}`);
-  }
-  for (const target of plan.targets ?? []) {
-    const targetFailures = [];
-    if (ids.has(target.id)) targetFailures.push(`${target.id}: duplicate target id`);
-    ids.add(target.id);
-    targetFailures.push(...validateTarget(target, entryMap, sourceIds));
-    targetReports.push({
-      id: target.id,
-      platform: target.platform,
-      status: target.status,
-      url: target.url,
-      contentEntryIds: target.contentEntryIds,
-      manualRuleCheckRequired: target.manualRuleCheckRequired,
-      ok: targetFailures.length === 0,
-      failures: targetFailures,
-    });
-    failures.push(...targetFailures);
-  }
-  for (const id of REQUIRED_TARGETS) {
-    if (!ids.has(id)) failures.push(`Missing browser-launch target: ${id}`);
-  }
-  const ordered = [...(plan.targets ?? [])]
-    .sort((a, b) => a.order - b.order)
-    .map(target => target.id);
-  if (ordered.join('|') !== REQUIRED_TARGETS.join('|')) {
-    failures.push(`Browser-launch target order must be ${REQUIRED_TARGETS.join(', ')}`);
-  }
-
-  return {
-    schemaVersion: '1.0.0',
-    suite: 'Audrey browser launch plan verification',
-    generatedAt: new Date().toISOString(),
-    ok: failures.length === 0,
-    plan: publicPath(fromRoot(options.plan ?? DEFAULT_PLAN)),
-    publicationPack: publicPath(fromRoot(plan.publicationPack)),
-    targets: targetReports,
-    failures,
-  };
-}
-
-async function main() {
-  const args = parseArgs();
-  if (args.help) {
-    console.log(usage());
-    return;
-  }
-
-  const report = await verifyBrowserLaunchPlan(args);
-  if (args.json) {
-    console.log(JSON.stringify(report, null, 2));
-  } else if (report.ok) {
-    console.log(`Browser launch plan verification passed: ${report.targets.length} target(s)`);
-  } else {
-    console.error('Browser launch plan verification failed:');
-    for (const failure of report.failures) console.error(`- ${failure}`);
-  }
-
-  if (!report.ok) process.exit(1);
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  main().catch(error => {
-    console.error(error.stack ?? error.message);
-    process.exit(1);
-  });
-}