@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/slopnators/sl_unversioned.ts

@@ -1,52 +0,0 @@
-import type { Slopnator } from '../slopnator.ts'
-import { here, parses, rowsIn } from './sl_unthreaded.ts'
-
-export const slopnator: Slopnator = {
-  holds: (_node, at) => {
-    const path = here(at.filename)
-
-    if (!parses(path)) return false
-
-    let governing: readonly { readonly list?: string; readonly id?: string; readonly version?: number }[]
-    try {
-      governing = rowsIn(at.text)
-    } catch {
-      return 'this file cannot be parsed, so the declarations it governs with were never read and nothing about their versions was measured'
-    }
-
-    for (const node of governing) {
-      if (node.list !== undefined || node.version !== undefined) continue
-      return (
-        `"${node.id ?? ''}" is annotated with the interface that makes other things conform to it and states no \`version\`, ` +
-        'so a change to what it governs is a diff nobody downstream can detect and nothing can be carried forward from the shape it used to have'
-      )
-    }
-
-    return false
-  },
-  proves: {
-    wrong: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_unversioned_probe.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_unversioned_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const L: Threaded = {\n  id: 'a-law',\n  at: 'thread/integrity/constraint.ts',\n  describes: 'A rule that must be enforced.',\n}\n" },
-          { at: 'thread/integrity/constraint.ts', source: 'export const CONSTRAINTS = []\n' },
-        ],
-        at: 'threads/_unversioned_probe.ts',
-      },
-    ],
-    right: [
-      {
-        files: [
-          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
-          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_unversioned_probe.ts',\n    },\n  ],\n}\n" },
-          { at: 'threads/_unversioned_probe.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const L: Threaded = {\n  id: 'a-law',\n  at: 'thread/integrity/constraint.ts',\n  describes: 'A rule that must be enforced.',\n  version: 3,\n}\n" },
-          { at: 'thread/integrity/constraint.ts', source: 'export const CONSTRAINTS = []\n' },
-        ],
-        at: 'threads/_unversioned_probe.ts',
-      },
-      "export const HELPER = {\n  id: 'a-helper',\n  at: 'threads/core.ts',\n  describes: 'Nothing conforms to this.',\n}",
-    ],
-  },
-}

package/dist/integrity/sweep.ts

@@ -1,395 +0,0 @@
-import { starts } from '../integrations/cli.ts'
-import { attached, existsSync, readFileSync, readdirSync } from '../integrations/disk.ts'
-import { join } from 'node:path'
-import { argv, stdout } from 'node:process'
-
-import { runChecker, type Finding } from '../core/finding.ts'
-import { exit, invoked } from '../core/invoked.ts'
-
-import { parser } from 'typescript-eslint'
-
-import { CONSTRAINTS, type Constraint, type Proof } from './constraint.ts'
-import { NOT_WRITTEN, ROOT, derivedHere, governs, load, proofsOf, reads, rules, slopnatorName, subject, sweeps, visits, type Reading, type Slopnator, type Spoken, type Visiting } from './slopnator.ts'
-import { crossed, deriveTrials, runTrials } from './generators/trial.ts'
-
-const PARSEABLE = /\.(ts|tsx|mts|cts|mjs|cjs|js|jsx)$/
-
-interface Node {
-  readonly type?: string
-  readonly comments?: readonly Spoken[]
-  readonly [key: string]: unknown
-}
-
-function tree(text: string): Node | undefined {
-  const read = (jsx: boolean): { ast: Node } =>
-    (parser.parseForESLint as (t: string, o: unknown) => { ast: Node })(text, {
-      range: true,
-      loc: true,
-      comment: true,
-      ecmaVersion: 'latest',
-      sourceType: 'module',
-      ecmaFeatures: { jsx },
-    })
-  try {
-    return read(true).ast
-  } catch {
-    try {
-      return read(false).ast
-    } catch {
-      return undefined
-    }
-  }
-}
-
-export function visit(root: Node, on: ReadonlySet<string>, each: (node: Node, ancestors: readonly Node[]) => void): void {
-  const stack: Node[] = []
-  const step = (held: unknown): void => {
-    if (held === null || typeof held !== 'object') return
-    if (Array.isArray(held)) {
-      for (const one of held) step(one)
-      return
-    }
-    const node = held as Node
-    const named = typeof node.type === 'string'
-    if (named && on.has(node.type as string)) each(node, [...stack])
-    if (named) stack.push(node)
-    for (const key of Object.keys(node)) {
-      if (key === 'parent') continue
-      step((node as Record<string, unknown>)[key])
-    }
-    if (named) stack.pop()
-  }
-  step(root)
-}
-
-const blank = (said: string): string => said.replace(/[^\n]/g, ' ')
-
-const sourcesIn = (one: Proof): readonly string[] =>
-  typeof one === 'string'
-    ? [one]
-    : one.files.flatMap((each) => (typeof each.source === 'string' ? [each.source] : []))
-
-function without(text: string, rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): string {
-  let said = text
-  for (const proof of proofsOf(rule, slopnators).wrong) {
-    for (const source of sourcesIn(proof)) {
-      for (const one of [source, source.trim()]) {
-        if (one === '') continue
-        said = said.replaceAll(one, blank(one))
-      }
-    }
-  }
-  return said
-}
-
-export interface Caught {
-  readonly rule: string
-  readonly file: string
-  readonly found: string
-}
-
-const ELSEWHERE = new Set(['node_modules', '.git'])
-
-function ignoredIn(root: string): ReadonlySet<string> {
-  const at = join(root, '.gitignore')
-  if (!existsSync(at)) return new Set()
-  return new Set(
-    readFileSync(at, 'utf8')
-      .split('\n')
-      .map((line) => line.trim().replace(/^\//, '').replace(/\/$/, ''))
-      .filter((line) => line !== '' && !line.startsWith('#') && !line.includes('*') && !line.startsWith('!')),
-  )
-}
-
-export function tracked(root: string): readonly string[] {
-  const derived = derivedHere()
-  const mine = (one: string): boolean => derived?.has(one) !== true
-
-  try {
-
-    const listed = starts('git', ['ls-files', '--cached', '--others', '--exclude-standard'], { at: root })
-      .out.split('\n')
-      .filter(Boolean)
-    if (!attached() && listed.length > 0) {
-      return [...new Set(listed)].filter((one) => existsSync(join(root, one)) && mine(one)).sort()
-    }
-  } catch {
-
-  }
-
-  const found: string[] = []
-  const ignored = ignoredIn(root)
-
-  const walk = (at: string, under: string): void => {
-    for (const one of readdirSync(at, { withFileTypes: true })) {
-      if (one.name.startsWith('.')) continue
-      if (ELSEWHERE.has(one.name) || ignored.has(one.name) || ignored.has(under === '' ? one.name : `${under}/${one.name}`)) continue
-      const here = under === '' ? one.name : `${under}/${one.name}`
-      if (one.isDirectory()) walk(join(at, one.name), here)
-      else if (mine(here)) found.push(here)
-    }
-  }
-
-  walk(root, '')
-  return found.sort()
-}
-
-export function sweep(
-  root: string,
-  all: readonly Constraint[],
-  slopnators: ReadonlyMap<string, Slopnator>,
-  files: readonly string[],
-): {
-  readonly findings: readonly Caught[]
-  readonly swept: number
-  readonly tracked: number
-  readonly rules: number
-  readonly unrun: readonly string[]
-  readonly unmet: readonly string[]
-  readonly linted: readonly string[]
-  readonly spent: ReadonlyMap<string, number>
-} {
-  const readers = all
-    .map((rule) => ({ rule, slopnator: slopnators.get(slopnatorName(rule.id)) }))
-    .filter((one): one is { rule: Constraint; slopnator: Reading } => one.slopnator !== undefined && sweeps(one.slopnator))
-
-  const walkers = all
-    .map((rule) => ({ rule, slopnator: slopnators.get(slopnatorName(rule.id)) }))
-    .filter((one): one is { rule: Constraint; slopnator: Visiting } => one.slopnator !== undefined && visits(one.slopnator))
-
-  const findings: Caught[] = []
-  let swept = 0
-  const spent = new Map<string, number>()
-  const timed = <T>(rule: string, work: () => T): T => {
-    const began = Date.now()
-    try {
-      return work()
-    } finally {
-      spent.set(rule, (spent.get(rule) ?? 0) + Date.now() - began)
-    }
-  }
-
-  const met = new Set<string>()
-
-  for (const file of files) {
-    const reading = readers.filter((one) => subject(one.rule) && governs(one.rule, file))
-    const walking = walkers.filter((one) => subject(one.rule) && governs(one.rule, file))
-    for (const one of reading) met.add(one.rule.id)
-    for (const one of walking) met.add(one.rule.id)
-    if (reading.length === 0 && walking.length === 0) continue
-
-    let text: string
-    try {
-      text = readFileSync(join(root, file), 'utf8')
-    } catch {
-      continue
-    }
-    swept += 1
-
-    for (const { rule, slopnator } of reading) {
-      const held = timed(rule.id, () =>
-        slopnator.holds(undefined, {
-          filename: file,
-          text: without(text, rule, slopnators),
-          ancestors: () => [],
-          comments: () => [],
-        }),
-      )
-      if (held === false || held === NOT_WRITTEN) continue
-      findings.push({ rule: rule.id, file, found: typeof held === 'string' ? held : slopnatorName(rule.id) })
-    }
-
-    if (walking.length === 0 || !PARSEABLE.test(file)) continue
-
-    const ast = tree(text)
-    if (ast === undefined) {
-      for (const { rule } of walking) {
-        findings.push({
-          rule: rule.id,
-          file,
-          found:
-            'this file could not be parsed, so nothing about its structure was measured — ' +
-            'a green result here says nothing about this rule on this file',
-        })
-      }
-      continue
-    }
-
-    const comments = ast.comments ?? []
-    for (const { rule, slopnator } of walking) {
-      const on = new Set(slopnator.on)
-      if (on.size === 0) {
-        findings.push({
-          rule: rule.id,
-          file,
-          found: 'its slopnator visits no node type, so it measured nothing here rather than finding nothing',
-        })
-        continue
-      }
-      timed(rule.id, () => visit(ast, on, (node, ancestors) => {
-        const held = slopnator.holds(node, {
-          filename: file,
-          text,
-          ancestors: () => ancestors,
-          comments: () => comments,
-        })
-        if (held === false || held === NOT_WRITTEN) return
-        findings.push({ rule: rule.id, file, found: typeof held === 'string' ? held : slopnatorName(rule.id) })
-      }))
-    }
-  }
-
-  for (const rule of all) {
-    const slopnator = slopnators.get(slopnatorName(rule.id))
-    if (slopnator === undefined || reads(slopnator)) continue
-    for (const found of timed(rule.id, () => slopnator.checks(root))) findings.push({ rule: rule.id, file: '', found })
-  }
-
-  const unrun = all.filter((rule) => slopnators.get(slopnatorName(rule.id)) === undefined).map((rule) => rule.id)
-  const linted = walkers.map((one) => one.rule.id)
-  const unmet = [...new Set([...readers, ...walkers].map((one) => one.rule.id))].filter((id) => !met.has(id)).sort()
-
-  return {
-    findings,
-    swept,
-    tracked: files.length,
-    unrun,
-    unmet,
-    linted,
-    spent,
-    rules:
-      readers.length +
-      walkers.length +
-      all.filter((rule) => {
-        const slopnator = slopnators.get(slopnatorName(rule.id))
-        return slopnator !== undefined && !reads(slopnator)
-      }).length,
-  }
-}
-
-if (invoked(import.meta.url)) {
-  const began = Date.now()
-  const declared = [...CONSTRAINTS, ...((await rules()) ?? [])]
-  let only: string | undefined
-  let flagged = false
-  for (const one of argv) {
-    if (flagged) {
-      only = one
-      break
-    }
-    if (one === '--only') flagged = true
-  }
-  let governing: readonly Constraint[] = []
-  for (const one of declared) {
-    const id = one['id']
-    if (only === undefined || id === only || slopnatorName(id) === only) governing = [...governing, one]
-  }
-  if (governing[0] === undefined) {
-    runChecker(
-      'sweep',
-      [
-        {
-          file: '',
-          detail: 'this tree declares no rule called ' + String(only),
-          instead:
-            'name a rule by its id, or by the slopnator beside it — `thread rules` lists both. Running all of them while ' +
-            'saying one was asked for is a green tick over a sweep nobody asked for, so nothing was swept',
-        },
-      ],
-      '',
-    )
-    exit(1)
-  }
-  const slopnators = await load(ROOT, governing)
-  const named = new Map(governing.map((rule) => [rule.id, rule]))
-  const loaded = Date.now()
-  const run = sweep(ROOT, governing, slopnators, tracked(ROOT))
-  const walked = Date.now()
-
-  const { default: plugin } = await import('./lint.ts')
-  const derived = deriveTrials(governing, slopnators).trials
-  const proving = runTrials(derived, governing, plugin.rules, parser, slopnators)
-  const proved = Date.now()
-  const crossing = new Map<string, number>()
-  const unproven = [
-    ...proving.outcomes.filter((one) => !one.passed),
-    ...crossed(derived, declared, plugin.rules, parser, await load(ROOT, declared), crossing),
-  ]
-  const done = Date.now()
-
-  const failing = new Map<string, string[]>()
-  for (const one of unproven) {
-    const held = failing.get(one.rule) ?? []
-    held.push(`      ${one.id} — ${one.failures.join('; ')}`)
-    failing.set(one.rule, held)
-  }
-
-  const warned = new Set<string>()
-  const grouped = new Map<string, string[]>()
-  const files = new Map<string, Set<string>>()
-  for (const finding of run.findings) {
-    if (named.get(finding.rule)?.severity === 'warning') warned.add(finding.rule)
-    const held = grouped.get(finding.rule) ?? []
-    held.push(finding.file === '' ? `      ${finding.found}` : `      ${finding.file} — ${finding.found}`)
-    grouped.set(finding.rule, held)
-    const where = files.get(finding.rule) ?? new Set<string>()
-    where.add(finding.file)
-    files.set(finding.rule, where)
-  }
-  const refused = new Set(run.findings.map((one) => one.file).filter((one) => one !== ''))
-
-  const findings: Finding[] = [
-    ...[...grouped.entries()].map(([id, where]): Finding => {
-      const rule = named.get(id)
-      const count = files.get(id)?.size ?? 0
-      const said = where.length === count ? `${String(count)} file(s)` : `${String(where.length)} finding(s) in ${String(count)} file(s)`
-      return {
-        detail: `${id} — ${rule?.bans ?? 'refused'}. ${said}:\n${where.sort().join('\n')}`,
-        instead: rule?.instead ?? `read what ${id} refuses and stop writing it`,
-        ...(rule?.severity === 'warning' ? { severity: 'warning' as const } : {}),
-      }
-    }),
-    ...[...failing.entries()].map(([id, why]): Finding => ({
-      detail: `${id} — ${String(why.length)} of its own trial(s) did not pass:\n${[...new Set(why)].sort().join('\n')}`,
-      instead:
-        'make the rule refuse the `wrong` it declares and accept the `right`, or correct the pair — a rule that has never fired on its own example is a rule nobody has seen work',
-    })),
-    ...run.unrun.map((rule): Finding => ({
-      detail: `${rule} DID NOT RUN — no slopnator is on disk for it, so this sweep measured nothing for that rule and a green result here says nothing about it`,
-      instead: 'write the walk the rule names, or delete the rule and its row together — half a rule reads as a whole one from every direction',
-    })),
-  ]
-
-  runChecker(
-    'sweep',
-    findings,
-    `each naming one rule and the files it refuses — ${String(run.findings.length)} refusal(s) across ${String(refused.size)} file(s), ` +
-      `over ${String(run.rules)} rule(s) run across ${String(run.swept)} of ${String(run.tracked)} file(s) in this tree, ` +
-      `${String(run.linted.length)} of them reading a syntax tree, and ${String(proving.passed)} of ${String(proving.outcomes.length)} rule trial(s) passed, ${String(proving.measured)} measured` +
-      `${run.unrun.length === 0 ? '' : `, ${String(run.unrun.length)} that DID NOT RUN AT ALL`}` +
-      `${run.unmet.length === 0 ? '' : `, and ${String(run.unmet.length)} that governed no file here and so measured nothing: ${run.unmet.join(', ')}`}`,
-  )
-  const seconds = (ms: number): string => String(Math.round(ms / 1000)) + ' s'
-  const slowest = (spent: ReadonlyMap<string, number>): string =>
-    [...spent.entries()]
-      .sort((one, two) => two[1] - one[1])
-      .slice(0, 3)
-      .map(([rule, ms]) => rule + ' ' + seconds(ms))
-      .join(', ')
-  const own = new Map(run.spent)
-  for (const [rule, ms] of proving.spent) own.set(rule, (own.get(rule) ?? 0) + ms)
-  stdout.write(
-    'sweep: it took ' + seconds(done - began) + '. Loading the rules took ' + seconds(loaded - began) +
-      ', reading the files in this tree ' + seconds(walked - loaded) +
-      ', running each rule on its own examples ' + seconds(proved - walked) +
-      ', and holding what each rule recommends against every other rule ' + seconds(done - proved) +
-      '. Slowest on their own files and examples: ' + slowest(own) +
-      '. Slowest to hold against the rest: ' + slowest(crossing) + '.\n',
-  )
-  const forbidding = findings.length - run.findings.filter((one) => named.get(one.rule)?.severity === 'warning').length
-  if (forbidding > 0) exit(1)
-  if (warned.size > 0) {
-    stdout.write(`sweep: every finding above is a warning — ${[...warned].sort().join(', ')} state \`severity: 'warning'\`, so the gate does not stop here.\n`)
-  }
-  exit(0)
-}