@prestack/thread 0.1.21 → 0.1.23

package/dist/integrity/lint.ts

@@ -1,214 +0,0 @@
-import { starts } from '../integrations/cli.ts'
-
-import { Linter, type Rule } from 'eslint'
-import tseslint from 'typescript-eslint'
-
-import { THING } from '../core/scope.ts'
-import { CONSTRAINTS, shown, type Constraint } from './constraint.ts'
-import {
-  NOT_WRITTEN,
-  governs,
-  subject,
-  reads,
-  visits,
-  load,
-  ROOT,
-  rules as appRules,
-  slopnatorName,
-  type Slopnator,
-  type SlopnatorContext,
-} from './slopnator.ts'
-
-export function ruleMessage(rule: Constraint): string {
-  const cites = (rule.cites ?? []).map((cite) => `${cite.on} — ${cite.said}`).join(' · ')
-  return cites === '' ? `${rule.bans} — ${rule.because}. Instead: ${rule.instead}.` : `${rule.bans} — ${rule.because}. Instead: ${rule.instead}. (${cites})`
-}
-
-const oneLine = (text: string): string => text.replace(/\s*\n\s*/g, ' ').trim()
-
-export function agentInstructions(): readonly string[] {
-  return [...CONSTRAINTS]
-    .sort((one, two) => (one.id < two.id ? -1 : one.id > two.id ? 1 : 0))
-    .map(
-      (rule) =>
-        `${oneLine(rule.instead)} — never ${oneLine(rule.bans)}. Wrong: \`${oneLine(shown(rule.wrong))}\`. Right: \`${oneLine(shown(rule.right))}\`. [${rule.id}]`,
-    )
-}
-
-export function defineRule(rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): Constraint {
-  const expected = slopnatorName(rule.id)
-
-  if (rule.where.paths.length === 0) {
-    throw new Error(
-      `rule "${rule.id}" names no path, so it governs nothing. A rule that cannot fire is indistinguishable from a rule being obeyed.`,
-    )
-  }
-
-  const found = slopnators.get(expected)
-  if (found === undefined) {
-    throw new Error(
-      `"${rule.id}" names "${expected}", and no such file is beside the tree or shipped with the package. ` +
-        'One that cannot run reads as enforced, reports nothing, and is indistinguishable from one being obeyed. ' +
-        'Seed it.',
-    )
-  }
-
-  return rule
-}
-
-export function defineRules(slopnators: ReadonlyMap<string, Slopnator>): readonly Constraint[] {
-  const seen = new Set<string>()
-  for (const rule of GOVERNING) {
-    if (seen.has(rule.id)) throw new Error(`rule "${rule.id}" is declared twice in packages/core/src/integrity/constraint.ts`)
-    seen.add(rule.id)
-    defineRule(rule, slopnators)
-  }
-  return GOVERNING
-}
-
-export function ruleRule(rule: Constraint, slopnators: ReadonlyMap<string, Slopnator>): Rule.RuleModule {
-  const slopnator = slopnators.get(slopnatorName(rule.id))
-  return {
-    meta: {
-      type: 'problem',
-      docs: { description: rule.bans },
-      schema: [],
-      ...(slopnator !== undefined && reads(slopnator) && slopnator.fixes !== undefined ? { fixable: 'code' as const } : {}),
-      messages: { broken: `${ruleMessage(rule)} Found: {{found}}.` },
-    },
-    create(context) {
-      if (!governs(rule, context.filename)) return {}
-      const found = slopnator
-      if (found === undefined || !visits(found)) return {}
-      const visit = (node: unknown): void => {
-        const at: SlopnatorContext = {
-          filename: context.filename.startsWith(ROOT) ? context.filename.slice(ROOT.length) : context.filename,
-          text: context.sourceCode.getText(),
-          ancestors: () => context.sourceCode.getAncestors(node as never),
-          comments: () =>
-            context.sourceCode.getAllComments().map((comment) => ({
-              value: comment.value,
-              range: (comment.range ?? [0, 0]) as readonly [number, number],
-            })),
-        }
-        const held = found.holds(node, at)
-        if (held === false || held === NOT_WRITTEN) return
-        const mend = found.fixes
-        const mended = mend === undefined ? undefined : mend(node, at)
-        context.report({
-          node: node as never,
-          messageId: 'broken',
-          data: { found: typeof held === 'string' ? held : slopnatorName(rule.id) },
-          ...(mended === undefined ? {} : { fix: (fixer) => fixer.replaceTextRange([0, at.text.length], mended) }),
-        })
-      }
-      return Object.fromEntries(found.on.map((type) => [type, visit]))
-    },
-  }
-}
-
-export function ruleRules(slopnators: ReadonlyMap<string, Slopnator>): Readonly<Record<string, Rule.RuleModule>> {
-  return Object.fromEntries(GOVERNING.map((rule) => [rule.id, ruleRule(rule, slopnators)]))
-}
-
-export function ruleSeverities(): Readonly<Record<string, 'error' | 'warn'>> {
-  return Object.fromEntries(
-    GOVERNING.filter((rule) => subject(rule)).map((rule) => [`lint/${rule.id}`, rule.severity === 'warning' ? ('warn' as const) : ('error' as const)]),
-  )
-}
-
-const GOVERNING = [...CONSTRAINTS, ...((await appRules()) ?? [])]
-const SLOPNATORS = await load(ROOT, GOVERNING)
-
-defineRules(SLOPNATORS)
-
-export const plugin = { rules: ruleRules(SLOPNATORS) }
-
-export default plugin
-
-function ignored(): readonly string[] {
-  try {
-    return starts('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory'], { at: ROOT })
-      .out.split('\n')
-      .filter(Boolean)
-      .map((one) => (one.endsWith('/') ? one + '**' : one))
-  } catch {
-    return []
-  }
-}
-
-export const rules = {
-  files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.mjs', '**/*.js'],
-  ignores: ignored(),
-  languageOptions: {
-    parser: tseslint.parser,
-    parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
-  },
-  plugins: { lint: plugin },
-  rules: ruleSeverities(),
-}
-
-export function ruleDeclarations(): readonly (Constraint & { readonly name: string })[] {
-  return [...CONSTRAINTS]
-    .sort((one, two) => (one.id < two.id ? -1 : one.id > two.id ? 1 : 0))
-    .map((rule) => ({ ...rule, name: rule.id }))
-}
-
-export interface RuleViolation {
-  readonly file: string
-  readonly line: number
-  readonly column: number
-  readonly rule: string
-
-  readonly message: string
-
-  readonly bans?: string
-
-  readonly instead?: string
-
-  readonly wrong?: string
-
-  readonly right?: string
-}
-
-export type RuleRunner = (file: string, source: string) => readonly RuleViolation[]
-
-export function theRules(): RuleRunner {
-  const linter = new Linter()
-  const declared = new Map(ruleDeclarations().map((one) => [one.name, one]))
-
-  const config = [
-    {
-      files: ['**/*.ts', '**/*.tsx', '**/*.mts', '**/*.cts'],
-
-      linterOptions: { noInlineConfig: true },
-      languageOptions: {
-        parser: tseslint.parser,
-        parserOptions: { ecmaVersion: 'latest', sourceType: 'module', ecmaFeatures: { jsx: true } },
-      },
-      plugins: { [`@${THING}`]: plugin },
-      rules: Object.fromEntries(
-        GOVERNING.filter((rule) => subject(rule)).map((rule) => [`@${THING}/${rule.id}`, rule.severity === 'warning' ? 'warn' : 'error']),
-      ),
-    },
-  ] as unknown as Parameters<InstanceType<typeof Linter>['verify']>[1]
-
-  return (file, source) =>
-    linter
-      .verify(source, config, file)
-      .filter((message) => message.ruleId != null)
-      .map((message) => {
-        const rule = String(message.ruleId).replace(`@${THING}/`, '')
-        const found = declared.get(rule)
-        return {
-          file,
-          line: message.line,
-          column: message.column,
-          rule,
-          message: message.message,
-          ...(found === undefined
-            ? {}
-            : { bans: found.bans, instead: found.instead, wrong: shown(found.wrong), right: shown(found.right) }),
-        }
-      })
-}

package/dist/integrity/lsp/bin.ts

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-
-import { cwd, stderr, stdin, stdout } from 'node:process'
-
-import { exit } from '../../core/invoked.ts'
-
-import { repoSource } from './diagnostics.ts'
-import { encode, MessageBuffer } from './protocol.ts'
-import { LspServer } from './server.ts'
-
-const server = new LspServer({
-  root: cwd(),
-  sourceFor: repoSource,
-  send: (message) => stdout.write(encode(message)),
-})
-
-const buffer = new MessageBuffer()
-
-let queue: Promise<void> = Promise.resolve()
-
-const fatal = (error: unknown): never => {
-  stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`)
-  exit(1)
-}
-
-stdin.on('data', (chunk: Buffer) => {
-  let messages
-  try {
-    messages = buffer.push(chunk)
-  } catch (error) {
-    fatal(error)
-    return
-  }
-
-  for (const message of messages) {
-    queue = queue.then(async () => {
-      await server.handle(message)
-      if (server.exited) exit(server.exitCode)
-    })
-    queue.catch(fatal)
-  }
-})
-
-stdin.on('end', () => exit(server.exitCode))

package/dist/integrity/lsp/diagnostics.ts

@@ -1,92 +0,0 @@
-import { readFileSync } from '../../integrations/disk.ts'
-import { join } from 'node:path'
-
-import { detailOf, rangeOf, type Finding } from './findings.ts'
-import { lintFindings } from './lint.ts'
-
-export interface DiagnosticSource {
-
-  lint(relative: string, text: string): Promise<readonly Finding[]>
-
-  read(relative: string): string | null
-}
-
-export function repoSource(root: string): DiagnosticSource {
-  return {
-    lint: (relative, text) => lintFindings(root, relative, text),
-    read: (relative) => {
-      try {
-        return readFileSync(join(root, relative), 'utf8')
-      } catch {
-
-        return null
-      }
-    },
-  }
-}
-
-export const ERROR = 1
-export const WARNING = 2
-
-export interface Position {
-  readonly line: number
-  readonly character: number
-}
-
-export interface Diagnostic {
-  readonly range: { readonly start: Position; readonly end: Position }
-  readonly severity: typeof ERROR | typeof WARNING
-  readonly source: string
-  readonly code: string
-  readonly message: string
-}
-
-export const SOURCE_NAME = 'thread'
-
-export function toDiagnostic(finding: Finding, text: string): Diagnostic {
-  const at = rangeOf(finding, text)
-  return {
-    range: {
-      start: { line: at.line - 1, character: at.column - 1 },
-      end: { line: (at.endLine ?? at.line) - 1, character: (at.endColumn ?? at.column) - 1 },
-    },
-    severity: finding.severity === 'error' ? ERROR : WARNING,
-    source: SOURCE_NAME,
-    code: finding.check,
-    message: detailOf(finding),
-  }
-}
-
-export async function report(
-  source: DiagnosticSource,
-  open: ReadonlyMap<string, string>,
-  previous: ReadonlySet<string> = new Set(),
-): Promise<ReadonlyMap<string, readonly Diagnostic[]>> {
-  const findings: Finding[] = []
-
-  for (const [relative, text] of open) {
-    findings.push(...(await source.lint(relative, text)))
-  }
-
-  const byFile = new Map<string, Finding[]>()
-  for (const finding of findings) {
-    const bucket = byFile.get(finding.file)
-    if (bucket === undefined) byFile.set(finding.file, [finding])
-    else bucket.push(finding)
-  }
-
-  const published = new Map<string, readonly Diagnostic[]>()
-  for (const [relative, group] of byFile) {
-    const text = open.get(relative) ?? source.read(relative) ?? ''
-    published.set(
-      relative,
-      group.map((finding) => toDiagnostic(finding, text)),
-    )
-  }
-
-  for (const relative of [...previous, ...open.keys()]) {
-    if (!published.has(relative)) published.set(relative, [])
-  }
-
-  return published
-}

package/dist/integrity/lsp/findings.ts

@@ -1,63 +0,0 @@
-export interface At {
-  readonly line: number
-  readonly column: number
-  readonly endLine?: number
-  readonly endColumn?: number
-}
-
-export interface Finding {
-  readonly severity: 'error' | 'warning'
-
-  readonly check: string
-  readonly detail: string
-
-  readonly file: string
-
-  readonly at?: At
-
-  readonly anchor?: string
-
-  readonly suggestions?: readonly string[]
-}
-
-export function detailOf(finding: Finding): string {
-  const offered = finding.suggestions ?? []
-  return offered.length === 0 ? finding.detail : `${finding.detail} ${offered.join(' ')}`
-}
-
-const DECLARED_ID = /\b[a-z]{2,6}_[a-z][a-z0-9_]*\b/g
-
-export function anchorIn(detail: string): string | undefined {
-  const candidates = [
-    ...(detail.match(DECLARED_ID) ?? []),
-    ...[...detail.matchAll(/"([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_*]+)+)"/g)].map((m) => m[1] as string),
-  ]
-  if (candidates.length === 0) return undefined
-  return candidates.reduce((longest, one) => (one.length > longest.length ? one : longest))
-}
-
-export function locate(text: string, anchor: string): At | undefined {
-  const lines = text.split('\n')
-  for (const [index, line] of lines.entries()) {
-    const column = line.indexOf(anchor)
-    if (column === -1) continue
-    return {
-      line: index + 1,
-      column: column + 1,
-      endLine: index + 1,
-      endColumn: column + 1 + anchor.length,
-    }
-  }
-  return undefined
-}
-
-export function headOf(text: string): At {
-  const first = text.split('\n')[0] ?? ''
-  return { line: 1, column: 1, endLine: 1, endColumn: Math.max(first.length, 1) + 1 }
-}
-
-export function rangeOf(finding: Finding, text: string): At {
-  if (finding.at !== undefined) return finding.at
-  const anchor = finding.anchor ?? anchorIn(finding.detail)
-  return (anchor === undefined ? undefined : locate(text, anchor)) ?? headOf(text)
-}

package/dist/integrity/lsp/lint.ts

@@ -1,124 +0,0 @@
-import { started } from '../../integrations/cli.ts'
-import { existsSync } from '../../integrations/disk.ts'
-import { extname, join } from 'node:path'
-
-import { theRules } from '../lint.ts'
-
-import type { Finding } from './findings.ts'
-
-interface EslintMessage {
-  readonly ruleId?: string | null
-  readonly severity: number
-  readonly message: string
-  readonly line?: number
-  readonly column?: number
-  readonly endLine?: number
-  readonly endColumn?: number
-
-  readonly suggestions?: readonly { readonly desc?: string }[]
-}
-
-interface EslintFile {
-  readonly messages?: readonly EslintMessage[]
-}
-
-const LINTABLE = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.mjs', '.cjs', '.jsx'])
-
-export const isLintable = (relative: string): boolean => LINTABLE.has(extname(relative))
-
-export const LINT_CONFIG = 'eslint.config.js'
-
-export class LintUnavailableError extends Error {
-  constructor(detail: string) {
-    super(
-      `ESLint could not be run over this repository: ${detail}. This server reports what the build ` +
-        'computes, so a lint pass that answered "no problems" because it never ran would be ' +
-        'indistinguishable from a clean file — which is the one thing it must never be.',
-    )
-    this.name = 'LintUnavailableError'
-  }
-}
-
-function binaryIn(root: string): string | undefined {
-  const local = join(root, 'node_modules', '.bin', 'eslint')
-  return existsSync(local) ? local : undefined
-}
-
-async function ruleFindings(relative: string, text: string): Promise<readonly Finding[]> {
-  const rules = theRules()
-  return rules(relative, text).map((violation) => ({
-    severity: 'error' as const,
-    check: violation.rule,
-
-    detail: violation.bans ?? violation.message,
-    file: relative,
-    at: { line: violation.line, column: violation.column },
-    suggestions: [
-      ...(violation.instead === undefined ? [] : [violation.instead]),
-      ...(violation.right === undefined ? [] : [`Write: ${violation.right}`]),
-    ],
-  }))
-}
-
-const suggestionsOf = (message: EslintMessage): readonly string[] =>
-  (message.suggestions ?? []).map((one) => one.desc).filter((desc): desc is string => desc !== undefined)
-
-export async function lintFindings(root: string, relative: string, text: string): Promise<readonly Finding[]> {
-  if (!isLintable(relative)) return []
-
-  if (!existsSync(join(root, LINT_CONFIG))) return await ruleFindings(relative, text)
-
-  const binary = binaryIn(root)
-  if (binary === undefined) {
-    return [
-      {
-        severity: 'error',
-        check: 'lint:unavailable',
-        detail:
-          `${LINT_CONFIG} is here and node_modules/.bin/eslint is not, so none of this repository's ` +
-          'rules are being checked while you type. Install the dev dependencies.',
-        file: LINT_CONFIG,
-      },
-    ]
-  }
-
-  const report = await runEslint(binary, root, relative, text)
-
-  return report.flatMap((file) =>
-    (file.messages ?? []).map((message) => ({
-      severity: message.severity === 2 ? ('error' as const) : ('warning' as const),
-      check: message.ruleId ?? 'lint',
-      detail: message.message,
-      file: relative,
-      at: {
-        line: message.line ?? 1,
-        column: message.column ?? 1,
-        ...(message.endLine === undefined ? {} : { endLine: message.endLine }),
-        ...(message.endColumn === undefined ? {} : { endColumn: message.endColumn }),
-      },
-      ...(suggestionsOf(message).length === 0 ? {} : { suggestions: suggestionsOf(message) }),
-    })),
-  )
-}
-
-async function runEslint(
-  binary: string,
-  root: string,
-  relative: string,
-  text: string,
-): Promise<readonly EslintFile[]> {
-  const went = await started(binary, ['--format', 'json', '--no-warn-ignored', '--stdin', '--stdin-filename', relative], {
-    at: root,
-    hears: text,
-  })
-  if (!went.there) throw new LintUnavailableError(went.why)
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(went.out)
-  } catch {
-    throw new LintUnavailableError(went.err.trim() === '' ? `it wrote ${went.out.length} bytes of non-JSON` : went.err.trim())
-  }
-  if (!Array.isArray(parsed)) throw new LintUnavailableError('its JSON report was not an array of files')
-  return parsed as readonly EslintFile[]
-}

package/dist/integrity/lsp/protocol.ts

@@ -1,78 +0,0 @@
-
-
-export interface RpcMessage {
-  readonly jsonrpc: '2.0'
-  readonly id?: number | string | null
-  readonly method?: string
-  readonly params?: unknown
-  readonly result?: unknown
-  readonly error?: { readonly code: number; readonly message: string }
-}
-
-const HEADER_END = '\r\n\r\n'
-
-export const METHOD_NOT_FOUND = -32601
-
-export function encode(message: RpcMessage): Buffer {
-  const body = Buffer.from(JSON.stringify(message), 'utf8')
-  return Buffer.concat([Buffer.from(`Content-Length: ${body.length}${HEADER_END}`, 'ascii'), body])
-}
-
-export class MalformedMessageError extends Error {
-  constructor(detail: string) {
-    super(
-      `the editor sent something this server cannot parse: ${detail}. ` +
-        'A language server that skipped it would answer the next request against a stream it no ' +
-        'longer understands, which reads as a file with no problems.',
-    )
-    this.name = 'MalformedMessageError'
-  }
-}
-
-export class MessageBuffer {
-  #pending: Buffer = Buffer.alloc(0)
-
-  push(chunk: Buffer): readonly RpcMessage[] {
-    this.#pending = Buffer.concat([this.#pending, chunk])
-
-    const found: RpcMessage[] = []
-    for (;;) {
-      const split = this.#pending.indexOf(HEADER_END, 0, 'ascii')
-      if (split === -1) return found
-
-      const header = this.#pending.subarray(0, split).toString('ascii')
-      const length = contentLength(header)
-      const start = split + HEADER_END.length
-
-      if (this.#pending.length < start + length) return found
-
-      const body = this.#pending.subarray(start, start + length).toString('utf8')
-      this.#pending = this.#pending.subarray(start + length)
-
-      let parsed: unknown
-      try {
-        parsed = JSON.parse(body)
-      } catch {
-        throw new MalformedMessageError(`a ${length}-byte body that is not JSON`)
-      }
-      if (typeof parsed !== 'object' || parsed === null) {
-        throw new MalformedMessageError(`a ${length}-byte body that is not a JSON object`)
-      }
-      found.push(parsed as RpcMessage)
-    }
-  }
-}
-
-function contentLength(header: string): number {
-  for (const line of header.split('\r\n')) {
-    const [name, value] = line.split(':', 2)
-
-    if (name?.trim().toLowerCase() !== 'content-length') continue
-    const length = Number.parseInt((value ?? '').trim(), 10)
-    if (!Number.isInteger(length) || length < 0) {
-      throw new MalformedMessageError(`Content-Length: ${(value ?? '').trim()}`)
-    }
-    return length
-  }
-  throw new MalformedMessageError(`a header block with no Content-Length: ${JSON.stringify(header)}`)
-}