@t275005746/gse 0.1.1 → 0.1.2

package/scripts/backfill-evidence-levels.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import path from 'node:path'
+
+const args = process.argv.slice(2)
+
+function readArg(name, fallback = null) {
+  const index = args.indexOf(name)
+  if (index === -1) return fallback
+  return args[index + 1] ?? fallback
+}
+
+const root = path.resolve(readArg('--root', path.join(import.meta.dirname, '..')))
+const execute = args.includes('--execute')
+const jsonOnly = args.includes('--json')
+const defaultLevel = readArg('--default-level', 'result')
+const evidenceIndexPath = path.join(root, '.gse', 'evidence', 'index.jsonl')
+const allowedLevels = new Set([
+  'result',
+  'verified-unit',
+  'verified-component',
+  'verified-api',
+  'verified-browser',
+  'verified-ci',
+  'accepted-owner',
+  'accepted-release',
+  'external-required',
+])
+
+function parseJsonl(filePath) {
+  if (!fs.existsSync(filePath)) return { records: [], errors: [{ line: 0, error: 'missing evidence index' }] }
+  const lines = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '').split(/\r?\n/)
+  const records = []
+  const errors = []
+  lines.forEach((line, index) => {
+    if (!line.trim()) return
+    try {
+      records.push(JSON.parse(line))
+    } catch (error) {
+      errors.push({ line: index + 1, error: error.message })
+    }
+  })
+  return { records, errors }
+}
+
+function summarize(record) {
+  return record.summary || record.recordType || '(unknown)'
+}
+
+if (!allowedLevels.has(defaultLevel)) {
+  console.error(`--default-level must be one of: ${[...allowedLevels].join(', ')}`)
+  process.exit(1)
+}
+
+const { records, errors } = parseJsonl(evidenceIndexPath)
+const missingBefore = records.filter((record) => !record.evidenceLevel)
+const updatedRecords = records.map((record) => {
+  if (record.evidenceLevel) return record
+  return {
+    ...record,
+    evidenceLevel: defaultLevel,
+    requiredEvidenceLevel: record.requiredEvidenceLevel || defaultLevel,
+    evidenceLevelBackfill: 'conservative-historical-default',
+  }
+})
+const missingAfter = updatedRecords.filter((record) => !record.evidenceLevel)
+const invalidAfter = updatedRecords.filter((record) => !allowedLevels.has(record.evidenceLevel))
+
+const report = {
+  root,
+  evidenceIndexPath,
+  execute,
+  defaultLevel,
+  summary: {
+    status: errors.length || invalidAfter.length ? 'failed' : execute ? 'written' : 'dry-run',
+    records: records.length,
+    missingBefore: missingBefore.length,
+    missingAfter: missingAfter.length,
+    invalidAfter: invalidAfter.length,
+  },
+  changed: missingBefore.slice(0, 20).map((record) => summarize(record)),
+  omittedChangedCount: Math.max(0, missingBefore.length - 20),
+  errors,
+  limits: [
+    'This script only fills missing historical evidenceLevel fields with a conservative default.',
+    'The default level should stay result unless a human or focused audit can prove a stronger level.',
+    'It does not rewrite evidence status or claim that old records were verified by a stronger proof type.',
+  ],
+}
+
+if (errors.length === 0 && invalidAfter.length === 0 && execute && missingBefore.length > 0) {
+  fs.writeFileSync(evidenceIndexPath, updatedRecords.map((record) => JSON.stringify(record)).join('\n') + '\n', 'utf8')
+}
+
+if (jsonOnly) console.log(JSON.stringify(report, null, 2))
+else console.log(JSON.stringify(report, null, 2))
+
+if (report.summary.status === 'failed') process.exit(1)

package/scripts/check-encoding.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+import path from 'node:path'
+import { TextDecoder } from 'node:util'
+import { spawnSync } from 'node:child_process'
+
+const root = path.resolve(process.cwd())
+const decoder = new TextDecoder('utf-8', { fatal: true })
+const textExtensions = new Set([
+  '.md',
+  '.json',
+  '.jsonl',
+  '.mjs',
+  '.js',
+  '.ts',
+  '.tsx',
+  '.yml',
+  '.yaml',
+  '.txt',
+  '.svg',
+  '.html',
+  '.css',
+  '.xml',
+])
+
+function gitFiles() {
+  const result = spawnSync('git', ['ls-files'], { cwd: root, encoding: 'utf8', windowsHide: true })
+  if ((result.status ?? 1) !== 0) {
+    throw new Error((result.stderr || result.stdout || 'git ls-files failed').trim())
+  }
+  return (result.stdout || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+}
+
+function isTextFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase()
+  return textExtensions.has(ext) || filePath === 'package.json' || filePath === 'README' || filePath.endsWith('.md')
+}
+
+const files = gitFiles().filter(isTextFile)
+const issues = []
+
+for (const file of files) {
+  const fullPath = path.join(root, file)
+  const buffer = fs.readFileSync(fullPath)
+  try {
+    decoder.decode(buffer)
+  } catch (error) {
+    issues.push({ file, issue: 'invalid-utf8', detail: error.message })
+    continue
+  }
+  if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+    issues.push({ file, issue: 'bom', detail: 'UTF-8 BOM present' })
+  }
+}
+
+const report = {
+  root,
+  generatedAt: new Date().toISOString(),
+  summary: {
+    status: issues.length === 0 ? 'passed' : 'failed',
+    passed: files.length - issues.length,
+    failed: issues.length,
+    total: files.length,
+  },
+  issues,
+}
+
+console.log(JSON.stringify(report, null, 2))
+if (issues.length > 0) process.exit(1)