@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/generators/compiler.ts

@@ -1,138 +0,0 @@
-
-import { readdirSync, readFileSync, writeFileSync } from '../../integrations/disk.ts'
-import { join, resolve } from 'node:path'
-import { argv, stderr, stdout } from 'node:process'
-
-import { exit } from '../../core/invoked.ts'
-import { ROOT, THREAD_AT, descend, uncompiled } from '../../core/descend.ts'
-
-import { forbids, runChecker, type Finding } from '../../core/finding.ts'
-
-function refuse(why: string): never {
-  stderr.write(`compiler: ${why}\n`)
-  exit(1)
-}
-
-const SOURCE = /\.(?:ts|tsx|mts|cts)$/
-const DECLARING = /\.d\.[cm]?ts$/
-
-const INSTALLED = 'node_' + 'modules'
-
-const pass = await descend()
-
-const stopped = [...pass.broken, ...pass.findings].filter(forbids)[0]
-if (stopped !== undefined) {
-  refuse(
-    'the descent is broken, so what this tree declares is short — and a short list of declarations ' +
-      `leaves out more of the app than it should, which is a compiler that agrees with anything. ${stopped.detail} (${stopped.file ?? ''})`,
-  )
-}
-
-const WORD = 'thread compiler'
-
-const SELF = [...pass.threaded.entries()]
-  .flatMap(([at, held]) => held.map((one) => ({ at, row: one.row })))
-  .filter((one) => (one.row.by ?? '') === WORD)
-  .find((one) => !one.at.split('/').includes(INSTALLED))
-
-if (SELF === undefined) {
-  refuse(
-    `no row in this tree names a file of this app with \`by: '${WORD}'\`, so nothing says which config is this app's. ` +
-      'Run `thread attach integrity`, which declares it.',
-  )
-}
-
-const AT = SELF.at
-const PATH = resolve(ROOT, AT)
-
-const declared = new Set([THREAD_AT, ...pass.threaded.keys()])
-
-function scan(rel: string): { readonly declares: boolean; readonly holds: boolean; readonly out: readonly string[] } {
-  let entries
-  try {
-    entries = readdirSync(join(ROOT, rel === '' ? '.' : rel), { withFileTypes: true })
-  } catch {
-    return { declares: false, holds: false, out: [] }
-  }
-
-  let declares = false
-  let holds = false
-  const out: string[] = []
-
-  for (const entry of [...entries].sort((one, two) => one.name.localeCompare(two.name))) {
-    if (entry.name === '.git' || entry.name === INSTALLED) continue
-    const at = rel === '' ? entry.name : `${rel}/${entry.name}`
-
-    if (entry.isDirectory()) {
-      const held = scan(at)
-      if (held.declares) {
-        declares = true
-        holds = true
-        out.push(...held.out)
-      } else if (held.holds) {
-        holds = true
-        out.push(at)
-      }
-      continue
-    }
-
-    if (declared.has(at)) {
-      declares = true
-      holds = true
-      continue
-    }
-    if (!SOURCE.test(entry.name) || DECLARING.test(entry.name)) continue
-    holds = true
-    out.push(at)
-  }
-
-  return { declares, holds, out }
-}
-
-const held = scan('')
-
-if (!held.declares) {
-  refuse(
-    'no TypeScript file in this tree is declared by anything, so every one of them would be left out ' +
-      'and the compiler would pass by reading nothing. Declare something with `thread create` first.',
-  )
-}
-
-const NEXT = '.next'
-
-const leave = [...new Set([...held.out, NEXT])].sort()
-
-let current: Record<string, unknown>
-try {
-  current = JSON.parse(readFileSync(PATH, 'utf8')) as Record<string, unknown>
-} catch (cause) {
-  refuse(`${AT} could not be read as JSON, so what it already states cannot be kept — ${String(cause)}`)
-}
-
-const wanted = JSON.stringify({ ...current, exclude: leave }, null, 2)
-const has = JSON.stringify(current.exclude ?? []) === JSON.stringify(leave)
-
-if (argv.includes('--check')) {
-  const findings: Finding[] = []
-  if (!has) {
-    findings.push({
-      file: AT,
-      detail: `does not leave out ${String(leave.length)} path(s) nothing in this tree declares, so the compiler is holding this app to code it never wrote`,
-      instead:
-        'run `thread compiler`. What the compiler reads is derived from what the tree declares — an edit here is a declaration somebody skipped, and a path put here by hand is taken back out on the next settle',
-    })
-  }
-  findings.push(...uncompiled())
-  runChecker('compiler', findings, `${String(leave.length)} path(s) left out, over ${String(pass.declarations)} declaration(s)`)
-  exit(findings.length > 0 ? 1 : 0)
-
-}
-
-if (has) {
-  stdout.write(`compiler: ${AT} already leaves out exactly what this tree declares nothing under.\n`)
-  exit(0)
-}
-
-writeFileSync(PATH, `${wanted}\n`)
-stdout.write(`compiler: wrote ${AT} — ${String(leave.length)} path(s) left out, declared by nobody: ${leave.join(', ')}.\n`)
-exit(0)

package/dist/integrity/generators/gate.ts

@@ -1,227 +0,0 @@
-import { starts } from '../../integrations/cli.ts'
-import { createHash } from 'node:crypto'
-import { join } from 'node:path'
-import { argv, execPath, stderr, stdout } from 'node:process'
-import { descend } from '../../core/descend.ts'
-import { attached, existsSync, here, readdirSync, readFileSync, rmSync, writeFileSync } from '../../integrations/disk.ts'
-import { LOADER, exit } from '../../core/invoked.ts'
-import { valuesIn } from '../../core/rows.ts'
-import { ORGANISATION, ours } from '../../core/scope.ts'
-import { findTree, inTree } from '../../core/tree.ts'
-
-const TREE = findTree()
-const ROOT = TREE.at
-
-const STEP_TIMEOUT = 600_000
-
-const { GATE } = valuesIn(readFileSync(inTree(TREE, 'gate.ts'))) as { GATE: { derives?: unknown; declares?: unknown } }
-const { GENERATORS } = valuesIn(readFileSync(inTree(TREE, 'derivation.ts'))) as { GENERATORS: readonly Record<string, unknown>[] }
-
-function refuse(why: string): never {
-  stderr.write(`gate: ${why}\n`)
-  exit(1)
-}
-
-interface Row {
-  readonly id?: string
-  readonly at?: string
-  readonly by?: string
-  readonly runs?: string
-}
-
-const rowsOf = (edge: unknown): readonly Row[] => (Array.isArray(edge) ? (edge as readonly Row[]) : [])
-
-interface Step {
-  readonly id: string
-  readonly runs: string
-}
-
-const walked = await descend()
-
-const every: readonly Row[] = [
-  ...rowsOf(GATE.declares),
-  ...rowsOf(GENERATORS),
-  ...[...walked.threaded.values()].flat().map((one) => one.row as Row),
-  ...[...walked.stated.values()].map((one) => one as Row),
-]
-
-function steps(): readonly Step[] {
-  const found: Step[] = []
-  const claimed = new Set<string>()
-
-  for (const row of every) {
-    const runs = (row.runs ?? '').trim()
-    if (runs === '' || claimed.has(runs)) continue
-    claimed.add(runs)
-    found.push({ id: row.id ?? runs, runs })
-  }
-
-  if (found.length === 0) {
-    refuse('no row in this tree names a command to check it, so the gate would pass by running nothing')
-  }
-
-  return found
-}
-
-const writers: readonly Row[] = [
-  ...rowsOf(GATE.declares),
-  ...rowsOf(GENERATORS),
-  ...[...walked.threaded.values()].flat().filter((one) => one.list === 'declares' && (one.row as Row).by === undefined).map((one) => one.row as Row),
-  ...[...walked.stated.values()].map((one) => one as Row),
-]
-
-const written = new Map<string, string>()
-
-for (const row of writers) {
-  const by = (row.by ?? '').trim()
-  const at = (row.at ?? '').trim()
-  if (by !== '' && at !== '' && !written.has(by)) written.set(by, at)
-}
-
-function ran(runs: string): number {
-  const said = runs.trim().split(/\s+/)
-  const spent = { at: ROOT, shows: true, within: STEP_TIMEOUT } as const
-
-  if (said[0] !== 'thread') {
-    const other = starts(said[0] ?? '', said.slice(1), spent)
-    return other.there ? other.code : 1
-  }
-
-  const of = `thread ${said[1] ?? ''}`
-  const at = written.get(of)
-  if (at === undefined) {
-    stderr.write(`gate: nothing in this tree is written by \`${of}\`, so this step names a command that does not exist here\n`)
-    return 1
-  }
-
-  if (attached()) {
-    const ordered = here().run(join(ROOT, at), said.slice(2))
-    stdout.write(ordered.out)
-    stderr.write(ordered.err)
-    return ordered.there ? ordered.code : 1
-  }
-
-  const spun = starts(execPath, [...LOADER, join(ROOT, at), ...said.slice(2)], spent)
-  return spun.there ? spun.code : 1
-}
-
-function named(flag: string): readonly string[] | undefined {
-  const at = argv.indexOf(flag)
-  if (at === -1) return undefined
-  return (argv[at + 1] ?? '').split(',').map((one) => one.trim()).filter(Boolean)
-}
-
-const all = steps()
-
-if (argv.includes('--list')) {
-  stdout.write(`gate: ${String(all.length)} step(s) declared\n`)
-  for (const step of all) stdout.write(`  ${step.id} — ${step.runs}\n`)
-  exit(0)
-}
-
-const only = named('--only')
-const skip = named('--skip') ?? []
-const known = new Set(all.map((step) => step.id))
-const unknown = [...(only ?? []), ...skip].filter((id) => !known.has(id))
-
-if (unknown.length > 0) {
-  stderr.write(`gate: no declared step is called ${unknown.join(', ')} — a filter naming nothing would run a shorter gate and exit 0\n`)
-  stderr.write(`gate: the declared steps are ${[...known].join(', ')}\n`)
-  exit(1)
-}
-
-const chosen = all.filter((step) => (only === undefined || only.includes(step.id)) && !skip.includes(step.id))
-const dropped = all.filter((step) => !chosen.includes(step))
-
-if (chosen.length === 0) {
-  stderr.write('gate: the filter selected no steps, and a gate that runs nothing must not exit 0\n')
-  exit(1)
-}
-
-const failed: Step[] = []
-const unmeasured: Step[] = []
-let passed = 0
-
-for (const [index, step] of chosen.entries()) {
-  const at = `step ${String(index + 1)} of ${String(chosen.length)}`
-  stdout.write(`\ngate: ${at} — ${step.runs} (${step.id})\n`)
-
-  if (attached() && step.runs.trim().split(/\s+/)[0] !== 'thread') {
-    unmeasured.push(step)
-    stdout.write(
-      `gate: ${at} — NOT RUN. \`${step.runs}\` is not a thread command, so it reads the disk of the machine this is\n` +
-        `running on rather than the tree being answered for. It would report on the wrong files, and a step that\n` +
-        `passed against the wrong machine says nothing about this one.\n`,
-    )
-    continue
-  }
-
-  const began = Date.now()
-  const code = ran(step.runs)
-
-  stdout.write(`gate: ${at} — exited ${String(code)} in ${String(Date.now() - began)} ms\n`)
-  if (code === 0) passed += 1
-  else failed.push(step)
-}
-
-stdout.write(`\ngate: ${String(passed)} of ${String(chosen.length)} steps passed.\n`)
-
-if (dropped.length > 0) {
-  stdout.write(`gate: PARTIAL RUN — ${String(dropped.length)} of ${String(all.length)} declared step(s) did not run: ${dropped.map((step) => step.id).join(', ')}\n`)
-  stdout.write('gate: this is not a gate pass. `thread gate` with no filter runs every step the tree declares.\n')
-}
-
-function fingerprint(): { readonly of: Record<string, string>; readonly versions: Record<string, string> } {
-  const of: Record<string, string> = {}
-  const hash = (at: string): void => {
-    if (!existsSync(join(ROOT, at))) return
-    of[at] = createHash('sha256').update(readFileSync(join(ROOT, at))).digest('hex').slice(0, 16)
-  }
-  const sheets = join(ROOT, '_threads')
-  if (existsSync(sheets)) {
-    for (const name of readdirSync(sheets)) if (name.endsWith('.ts')) hash(join('_threads', name))
-  }
-
-  const versions: Record<string, string> = {}
-  const held = join(ROOT, 'node_modules', ORGANISATION)
-  if (existsSync(held)) {
-    for (const name of readdirSync(held)) {
-      const pkg = `${ORGANISATION}/${name}`
-      if (!ours(pkg)) continue
-      const at = join(held, name, 'package.json')
-      if (!existsSync(at)) continue
-      const read = JSON.parse(readFileSync(at, 'utf8')) as { version?: string }
-      if (typeof read.version === 'string') versions[pkg] = read.version
-    }
-  }
-  return { of, versions }
-}
-
-const RECEIPT_AT = join('.thread', 'gate.json')
-const RECEIPT = join(ROOT, RECEIPT_AT)
-
-if (unmeasured.length > 0) {
-  stdout.write(
-    `gate: ${String(unmeasured.length)} step(s) could not be measured here — ${unmeasured.map((step) => step.id).join(', ')}. Each one\n` +
-      `runs a tool that is not part of this framework, so it reads whatever disk it was started on. This is not a\n` +
-      `gate pass, and no receipt is written for a run that left them unanswered.\n`,
-  )
-}
-
-if (failed.length === 0 && dropped.length === 0 && unmeasured.length === 0) {
-  writeFileSync(RECEIPT, `${JSON.stringify({ passed: chosen.length, ...fingerprint() }, null, 2)}\n`, 'utf8')
-  stdout.write(`gate: wrote ${RECEIPT_AT} — what compiles is checked against this, so a tree that skipped the gate does not build.\n`)
-} else if (existsSync(RECEIPT)) {
-
-  rmSync(RECEIPT)
-  stdout.write(`gate: removed ${RECEIPT_AT} — the tree no longer passes, so nothing may compile against an older run.\n`)
-}
-
-if (failed.length === 0) exit(unmeasured.length === 0 ? 0 : 1)
-
-stderr.write(
-  `gate: FAILED — ${String(failed.length)} of ${String(chosen.length)} step(s). The other ${String(passed)} ran and passed; a failing step stops nothing.\n`,
-)
-for (const step of failed) stderr.write(`  - ${step.id} — run it alone with \`${step.runs}\`\n`)
-stderr.write('gate: every step above is its own command. Run the failing one on its own to work on it, and `thread issues` for everything wrong with the tree at once.\n')
-exit(1)

package/dist/integrity/generators/issues.ts

@@ -1,160 +0,0 @@
-import { argv, stderr, stdout } from 'node:process'
-
-import { exit } from '../../core/invoked.ts'
-import { uncompiled } from '../../core/descend.ts'
-
-import { THREAD_AT, descend, refusals, trackedFiles, unthreaded, type Finding } from '../check-threads.ts'
-import { CONSTRAINTS } from '../constraint.ts'
-import { ruleMessage } from '../lint.ts'
-import { ROOT, load, rules } from '../slopnator.ts'
-import { sweep, tracked as governed } from '../sweep.ts'
-
-const WITHIN = '--in'
-
-const CHECK = '--check'
-
-const checking = argv.includes(CHECK)
-
-const scoped = argv.indexOf(WITHIN)
-const under = scoped === -1 ? undefined : argv[scoped + 1]
-if (scoped !== -1 && (under === undefined || under.startsWith('-'))) {
-  stderr.write(`thread issues ${WITHIN} <path> — which directory to report on. The totals still count the whole tree.\n`)
-  exit(1)
-}
-
-const inside = (one: Finding): boolean =>
-  under === undefined || one.file === undefined || one.file === under || one.file.startsWith(`${under.replace(/\/+$/, '')}/`)
-
-const pass = await descend()
-const tracked = trackedFiles()
-const kept = new Set(tracked)
-
-const found = refusals(pass, tracked)
-
-const loose = new Set(unthreaded(pass, tracked))
-
-const governing = [...CONSTRAINTS, ...((await rules()) ?? [])]
-const named = new Map(governing.map((one) => [one.id, one]))
-const ran = sweep(ROOT, governing, await load(ROOT, governing), governed(ROOT))
-
-const refused: readonly Finding[] = [
-  ...ran.findings.map((one): Finding => {
-    const rule = named.get(one.rule)
-    return {
-      detail: `${rule === undefined ? one.rule : ruleMessage(rule)} Found: ${one.found}.`,
-      instead: rule?.instead ?? `read what ${one.rule} refuses and stop writing it`,
-      ...(one.file === '' ? {} : { file: one.file }),
-    }
-  }),
-  ...ran.unrun.map((one): Finding => ({
-    detail: `${one} DID NOT RUN — no slopnator is on disk for it, so nothing here measured that rule and its absence from this list 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',
-  })),
-]
-
-const warned = found.filter((one) => one.severity === 'warning')
-const firm = found.filter((one) => one.severity !== 'warning')
-const cut = firm.filter((one) => one.file !== undefined && loose.has(one.file))
-const rest = firm.filter((one) => !(one.file !== undefined && loose.has(one.file)))
-const wrong = uncompiled().filter((one) => one.file === undefined || kept.has(one.file))
-
-const where = (one: Finding): string => {
-  const line = one.at?.line
-  const column = one.at?.column
-  return `${one.file ?? '(nowhere named)'}${line === undefined ? '' : `:${String(line)}${column === undefined ? '' : `:${String(column)}`}`}`
-}
-
-const listed = (held: readonly Finding[]): readonly string[] =>
-  held.flatMap((one) => [`  ${where(one)}`, `    ${one.detail}`, `    fix: ${one.instead}`, ''])
-
-const out: string[] = []
-
-let shown = 0
-
-const group = (title: string, taught: string, held: readonly Finding[]): void => {
-  if (held.length === 0) return
-  const here = held.filter(inside)
-  shown += here.length
-  if (here.length === 0) return
-  out.push(
-    '',
-    `${title} — ${String(held.length)}${here.length === held.length ? '' : `, ${String(here.length)} of them under ${String(under)}`}`,
-    taught,
-    '',
-    ...listed(here),
-  )
-}
-
-group(
-  'files nothing declares',
-  '  every file here is named by a row, or it is not part of this app. The descent starts at\n' +
-    `  ${THREAD_AT} and walks what each row declares; whatever it never arrives at is not wired,\n` +
-    '  however well it reads. Declare it with `thread create`, or delete it.',
-  cut,
-)
-
-group(
-  'files that will not compile',
-  '  nothing in this tree builds, serves or gates while one of its files does not typecheck.\n' +
-    '  Read off the same program the descent judged the declarations with.',
-  wrong,
-)
-
-group(
-  'declarations this tree refuses',
-  '  the files are reached and they compile; these are the things the descent will not accept about\n' +
-    '  how they are declared.',
-  rest,
-)
-
-group(
-  'what the rules refuse',
-  '  every rule this framework ships and every rule this app added, run over the files each one\n' +
-    `  governs — ${String(ran.rules)} rule(s) over ${String(ran.swept)} of ${String(ran.tracked)} tracked file(s).\n` +
-    '  This is what `thread sweep` reports, said here so one read answers the whole question.',
-  refused,
-)
-
-group(
-  'derivations nothing has produced yet',
-  '  each row here states what a generator would write, and no file is there. A generator that refuses\n' +
-    '  to write an empty file is doing its job, so the descent says these and does not refuse them, and\n' +
-    '  neither does this. Run the command the row names in `by` to produce the file.',
-  warned,
-)
-
-const total = cut.length + wrong.length + rest.length + refused.length
-
-const saidNotCounted = (): void => {
-  if (warned.length === 0) return
-  stdout.write(`issues: ${String(warned.length)} derivation(s) nothing has produced yet — listed below, said and not counted.\n`)
-}
-
-if (total === 0) {
-  stdout.write(
-    `issues: none — ${String(tracked.length)} tracked file(s), every one of them declared by a row, and all of them compile.\n` +
-      'issues: that is what a threaded tree is. Nothing here is written by hand; everything here was declared.\n',
-  )
-  saidNotCounted()
-  if (out.length > 0) stdout.write(`${out.join('\n')}\n`)
-  exit(0)
-}
-
-stdout.write(
-  `issues: ${String(total)} — ${String(cut.length)} file(s) nothing declares, ${String(wrong.length)} that will not compile, ` +
-    `${String(rest.length)} declared in a way it refuses, ${String(refused.length)} the rules refuse, over ${String(tracked.length)} tracked file(s).\n`,
-)
-saidNotCounted()
-stdout.write(
-  under === undefined
-    ? `issues: listing all ${String(total)} below. \`thread issues ${WITHIN} <path>\` reports on one directory instead.\n`
-    : `issues: listing the ${String(shown)} of them under ${under}. The counts above are the whole tree.\n`,
-)
-stdout.write(
-  checking
-    ? `issues: ${CHECK} refuses while any of these stand. Without it this reads and never refuses, so it still answers on a tree that is entirely broken.\n`
-    : `issues: this reads and never refuses, so it works on a tree that is entirely broken. Run it with ${CHECK}, which is what the gate runs, to have it refuse instead.\n`,
-)
-
-stdout.write(`${out.join('\n')}\n`)
-exit(checking ? 1 : 0)