@prestack/thread 0.1.20 → 0.1.22

package/dist/core/rows.ts

@@ -1,459 +0,0 @@
-import { createHash } from 'node:crypto'
-
-import ts from 'typescript'
-
-export interface Bounds {
-  readonly open: number
-  readonly close: number
-}
-
-const PARSED = new Map<string, ts.SourceFile>()
-
-function tree(text: string): ts.SourceFile {
-  const held = PARSED.get(text)
-  if (held !== undefined) return held
-  const made = ts.createSourceFile('rows.ts', text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-  if (PARSED.size > 8) PARSED.clear()
-  PARSED.set(text, made)
-  return made
-}
-
-function walk(node: ts.Node, seen: (one: ts.Node) => void): void {
-  seen(node)
-  ts.forEachChild(node, (one) => {
-    walk(one, seen)
-  })
-}
-
-const keyed = (one: ts.PropertyAssignment): string | undefined =>
-  ts.isIdentifier(one.name) || ts.isStringLiteral(one.name) ? one.name.text : undefined
-
-function stringy(node: ts.ObjectLiteralExpression, name: string): string | undefined {
-  for (const one of node.properties) {
-    if (!ts.isPropertyAssignment(one) || keyed(one) !== name) continue
-    return ts.isStringLiteral(one.initializer) ? one.initializer.text : undefined
-  }
-  return undefined
-}
-
-function listy(node: ts.ObjectLiteralExpression, name: string): ts.ArrayLiteralExpression | undefined {
-  for (const one of node.properties) {
-    if (!ts.isPropertyAssignment(one) || keyed(one) !== name) continue
-    return ts.isArrayLiteralExpression(one.initializer) ? one.initializer : undefined
-  }
-  return undefined
-}
-
-const spanned = (node: ts.Node): { readonly open: number; readonly close: number } => ({
-  open: node.getStart(),
-  close: node.getEnd() - 1,
-})
-
-export function inCode(text: string): readonly boolean[] {
-  const held = new Array<boolean>(text.length).fill(true)
-  let cursor = 0
-  while (cursor < text.length) {
-    const one = text[cursor]
-    const next = text[cursor + 1]
-    if (one === '/' && next === '/') {
-      while (cursor < text.length && text[cursor] !== '\n') held[cursor++] = false
-      continue
-    }
-    if (one === '/' && next === '*') {
-      held[cursor++] = false
-      held[cursor++] = false
-      while (cursor < text.length && !(text[cursor] === '*' && text[cursor + 1] === '/')) held[cursor++] = false
-      held[cursor++] = false
-      held[cursor++] = false
-      continue
-    }
-    if (one === "'" || one === '"' || one === '`') {
-      held[cursor++] = false
-      while (cursor < text.length && text[cursor] !== one) {
-        if (text[cursor] === '\\') held[cursor++] = false
-        held[cursor++] = false
-      }
-      held[cursor++] = false
-      continue
-    }
-    cursor += 1
-  }
-  return held
-}
-
-export function matched(text: string, code: readonly boolean[], from: number, open: string, close: string): number {
-  let depth = 0
-  for (let cursor = from; cursor < text.length; cursor += 1) {
-    if (code[cursor] !== true) continue
-    if (text[cursor] === open) depth += 1
-    if (text[cursor] === close) {
-      depth -= 1
-      if (depth === 0) return cursor
-    }
-  }
-  return -1
-}
-
-export function listBounds(text: string, list: string): Bounds | undefined {
-  const file = tree(text)
-
-  let found: ts.ArrayLiteralExpression | undefined
-  let held: ts.ObjectLiteralExpression | undefined
-
-  walk(file, (node) => {
-    if (found !== undefined || !ts.isVariableDeclaration(node) || node.initializer === undefined) return
-
-    const unwrapped = (node2: ts.Expression): ts.Expression =>
-      ts.isAsExpression(node2) || ts.isSatisfiesExpression(node2) ? unwrapped(node2.expression) : node2
-    const one = unwrapped(node.initializer)
-    if (ts.isIdentifier(node.name) && node.name.text === list && ts.isArrayLiteralExpression(one)) {
-      found = one
-      return
-    }
-    if (held === undefined && ts.isObjectLiteralExpression(one)) held = one
-  })
-
-  if (found !== undefined) return spanned(found)
-  if (held === undefined) return undefined
-  const inside = listy(held, list)
-  return inside === undefined ? undefined : spanned(inside)
-}
-
-export function nestedBounds(text: string, where: Bounds, parent: string, list: string): Bounds | undefined {
-  const row = rowAt(text, where, parent)
-  if (row === undefined) return undefined
-  const inside = listy(row, list)
-  return inside === undefined ? undefined : spanned(inside)
-}
-
-function elements(text: string, where: Bounds): readonly ts.ObjectLiteralExpression[] {
-  let found: ts.ArrayLiteralExpression | undefined
-  walk(tree(text), (node) => {
-    if (found !== undefined) return
-    if (ts.isArrayLiteralExpression(node) && node.getStart() === where.open && node.getEnd() - 1 === where.close) {
-      found = node
-    }
-  })
-  if (found === undefined) return []
-  return found.elements.filter((one): one is ts.ObjectLiteralExpression => ts.isObjectLiteralExpression(one))
-}
-
-function rowAt(text: string, where: Bounds, id: string): ts.ObjectLiteralExpression | undefined {
-  return elements(text, where).find((one) => stringy(one, 'id') === id)
-}
-
-export function holdsRow(text: string, where: Bounds, id: string): boolean {
-  return rowAt(text, where, id) !== undefined
-}
-
-export function seededAt(text: string, where: Bounds, id: string): string | undefined {
-  const held = rowAt(text, where, id)
-  if (held === undefined) return undefined
-  const seeds = listy(held, 'seeds')
-  const derives = listy(held, 'derives')
-  if (seeds !== undefined && derives !== undefined) return undefined
-  const first = (seeds ?? derives)?.elements[0]
-  if (first === undefined || !ts.isObjectLiteralExpression(first)) return undefined
-  return stringy(first, 'at')
-}
-
-export function rowsIn(
-  text: string,
-  where: Bounds,
-): readonly { readonly id: string; readonly at: string | undefined; readonly source: string }[] {
-  const found: { id: string; at: string | undefined; source: string }[] = []
-  for (const one of elements(text, where)) {
-    const id = stringy(one, 'id')
-    if (id === undefined) continue
-
-    const at = stringy(one, 'at')
-    const from = one.getStart()
-    const line = text.lastIndexOf('\n', from) + 1
-    const pad = text.slice(line, from)
-    found.push({ id, at, source: `${/^[ \t]*$/.test(pad) ? pad : ''}${text.slice(from, one.getEnd())},` })
-  }
-  return found
-}
-
-export function withRow(text: string, where: Bounds, row: string): string {
-  const held = /[ \t]*$/.exec(text.slice(0, where.close))?.[0] ?? ''
-  const before = text.slice(0, where.close - held.length)
-  const empty = before.trimEnd().endsWith('[')
-  const line = text.lastIndexOf('\n', where.open)
-  const pad = empty ? (/^[ \t]*/.exec(text.slice(line + 1))?.[0] ?? '') : held
-  return `${before}${empty ? '\n' : ''}${row}\n${pad}${text.slice(where.close)}`
-}
-
-export function withSeed(text: string, where: Bounds, id: string, seed: string): string {
-  const held = rowAt(text, where, id)
-  if (held === undefined) return text
-  if (listy(held, 'seeds') !== undefined) return text
-
-  const to = held.getEnd() - 1
-  const line = text.lastIndexOf('\n', held.getStart())
-  const pad = /^[ \t]*/.exec(text.slice(line + 1))?.[0] ?? '  '
-  const before = text.slice(0, to).trimEnd()
-  const comma = before.endsWith(',') ? '' : ','
-  return `${before}${comma}\n${pad}  seeds: [\n${seed}\n${pad}  ],\n${pad}${text.slice(to)}`
-}
-
-export function withRequires(text: string, where: Bounds, id: string, requires: readonly string[]): string | undefined {
-  const held = rowAt(text, where, id)
-  if (held === undefined) return undefined
-
-  const line = text.lastIndexOf('\n', held.getStart()) + 1
-  const pad = `${/^[ \t]*/.exec(text.slice(line))?.[0] ?? '  '}  `
-  const written = requires.length === 0 ? '' : `${pad}requires: [${requires.map((one) => `'${one}'`).join(', ')}],\n`
-
-  const propertyNamed = (name: string): ts.PropertyAssignment | undefined => {
-    for (const one of held.properties) {
-      if (ts.isPropertyAssignment(one) && keyed(one) === name) return one
-    }
-    return undefined
-  }
-
-  const already = propertyNamed('requires')
-  if (already !== undefined) {
-    const opens = text.lastIndexOf('\n', already.getStart()) + 1
-    const shut = text.indexOf('\n', already.getEnd())
-    return `${text.slice(0, opens)}${written}${text.slice(shut === -1 ? text.length : shut + 1)}`
-  }
-
-  const version = propertyNamed('version')
-  if (version === undefined) return undefined
-  const after = text.indexOf('\n', version.getEnd())
-  const at = after === -1 ? text.length : after + 1
-  return `${text.slice(0, at)}${written}${text.slice(at)}`
-}
-
-export function seedsIn(text: string, where: Bounds, id: string): Bounds | undefined {
-  const held = rowAt(text, where, id)
-  if (held === undefined) return undefined
-  const list = listy(held, 'seeds')
-  return list === undefined ? undefined : spanned(list)
-}
-
-export function afterRow(text: string, where: Bounds, follows: string, row: string): string | undefined {
-  const held = rowAt(text, where, follows)
-  if (held === undefined) return undefined
-  let to = held.getEnd()
-  if (text[to] === ',') to += 1
-  return `${text.slice(0, to)}\n${row}${text.slice(to)}`
-}
-
-function headed(text: string): ts.ObjectLiteralExpression | undefined {
-  let found: ts.ObjectLiteralExpression | undefined
-  walk(tree(text), (node) => {
-    if (found !== undefined || !ts.isVariableDeclaration(node) || node.initializer === undefined) return
-    const one = ts.isAsExpression(node.initializer) ? node.initializer.expression : node.initializer
-    if (ts.isObjectLiteralExpression(one)) found = one
-  })
-  return found
-}
-
-function stated(node: ts.ObjectLiteralExpression, field: string): Bounds | undefined {
-  for (const one of node.properties) {
-    if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
-    return { open: one.initializer.getStart(), close: one.initializer.getEnd() }
-  }
-  return undefined
-}
-
-export const quoted = (one: string): string => `'${one.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n')}'`
-
-const UNREAD = Symbol.for('thread.unread')
-
-function valued(node: ts.Expression): unknown {
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text
-  if (ts.isNumericLiteral(node)) return Number(node.text)
-  if (node.kind === ts.SyntaxKind.TrueKeyword) return true
-  if (node.kind === ts.SyntaxKind.FalseKeyword) return false
-  if (node.kind === ts.SyntaxKind.NullKeyword) return null
-  if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node)) return valued(node.expression)
-  if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
-    const held = valued(node.operand)
-    return typeof held === 'number' ? -held : UNREAD
-  }
-  if (ts.isArrayLiteralExpression(node)) {
-    const held: unknown[] = []
-    for (const one of node.elements) {
-      const each = valued(one)
-      if (each === UNREAD) return UNREAD
-      held.push(each)
-    }
-    return held
-  }
-  if (ts.isObjectLiteralExpression(node)) {
-    const held: Record<string, unknown> = {}
-    for (const one of node.properties) {
-      if (!ts.isPropertyAssignment(one)) return UNREAD
-      const key = keyed(one)
-      if (key === undefined) return UNREAD
-      const each = valued(one.initializer)
-      if (each === UNREAD) return UNREAD
-      held[key] = each
-    }
-    return held
-  }
-  return UNREAD
-}
-
-function taken(text: string): readonly (readonly [string, unknown])[] {
-  const found: (readonly [string, unknown])[] = []
-  walk(tree(text), (node) => {
-    if (!ts.isVariableDeclaration(node) || node.initializer === undefined || !ts.isIdentifier(node.name)) return
-    found.push([node.name.text, valued(node.initializer)])
-  })
-  return found
-}
-
-export function valuesIn(text: string): Readonly<Record<string, unknown>> {
-  const found: Record<string, unknown> = {}
-  for (const [name, held] of taken(text)) {
-    if (held !== UNREAD) found[name] = held
-  }
-  return found
-}
-
-export function unread(text: string): readonly string[] {
-  return taken(text).filter(([, held]) => held === UNREAD).map(([name]) => name)
-}
-
-export const STATED = ['at', 'describes', 'version']
-
-export function reconciled(held: string, source: string, fields: readonly string[]): string {
-  const ships = headed(source)
-  if (ships === undefined) return held
-  const named = stringy(ships, 'id')
-
-  let next = held
-  for (const field of fields) {
-    const want = stated(ships, field)
-    if (want === undefined) continue
-
-    const mine = headed(next)
-    if (mine === undefined || stringy(mine, 'id') !== named) return held
-    const have = stated(mine, field)
-    if (have === undefined) continue
-    const said = source.slice(want.open, want.close)
-    if (next.slice(have.open, have.close) === said) continue
-    next = next.slice(0, have.open) + said + next.slice(have.close)
-  }
-  return next
-}
-
-export function fieldIn(text: string, where: Bounds, id: string, field: string): string | undefined {
-  const held = rowAt(text, where, id)
-  if (held === undefined) return undefined
-  for (const one of held.properties) {
-    if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
-    return text.slice(one.initializer.getStart(), one.initializer.getEnd())
-  }
-  return undefined
-}
-
-export function withField(
-  text: string,
-  where: Bounds,
-  id: string,
-  field: string,
-  value: string,
-): string | undefined {
-  const held = rowAt(text, where, id)
-  return held === undefined ? undefined : fieldOn(text, held, field, value)
-}
-
-export function withTopField(text: string, field: string, value: string): string | undefined {
-  const held = headed(text)
-  return held === undefined ? undefined : fieldOn(text, held, field, value)
-}
-
-export function withoutField(text: string, where: Bounds, id: string, field: string): string {
-  const held = rowAt(text, where, id)
-  const one = held?.properties.find((each) => ts.isPropertyAssignment(each) && keyed(each) === field)
-  if (held === undefined || one === undefined) return text
-  let ends = one.getEnd()
-  if (text[ends] === ',') ends += 1
-  const line = text.lastIndexOf('\n', one.getStart())
-  if (line > held.getStart()) return text.slice(0, line) + text.slice(ends)
-  return text.slice(0, one.getStart()) + text.slice(text[ends] === ' ' ? ends + 1 : ends)
-}
-
-function fieldOn(text: string, held: ts.ObjectLiteralExpression, field: string, value: string): string | undefined {
-  for (const one of held.properties) {
-    if (!ts.isPropertyAssignment(one) || keyed(one) !== field) continue
-    return `${text.slice(0, one.initializer.getStart())}${value}${text.slice(one.initializer.getEnd())}`
-  }
-
-  const last = held.properties.at(-1)
-  if (last === undefined) return undefined
-
-  let ends = last.getEnd()
-  if (text[ends] === ',') ends += 1
-  const already = text[ends - 1] === ',' ? '' : ','
-
-  if (!text.slice(held.getStart(), held.getEnd()).includes('\n')) {
-    return `${text.slice(0, ends)}${already} ${field}: ${value}${text.slice(ends)}`
-  }
-
-  const line = text.lastIndexOf('\n', last.getStart()) + 1
-  const pad = /^[ \t]*/.exec(text.slice(line))?.[0] ?? '  '
-  return `${text.slice(0, ends)}${already}\n${pad}${field}: ${value},${text.slice(ends)}`
-}
-
-export function withoutRow(text: string, where: Bounds, id: string): string {
-  const held = rowAt(text, where, id)
-  if (held === undefined) return text
-  let ends = held.getEnd()
-  if (text[ends] === ',') ends += 1
-  const pad = /[ \t]*$/.exec(text.slice(0, held.getStart()))?.[0] ?? ''
-  const from = held.getStart() - pad.length
-  if (text[ends] === '\n') ends += 1
-  const left = text.slice(0, from)
-  const right = text.slice(ends)
-  return left.trimEnd().endsWith('[') && right.trimStart().startsWith(']')
-    ? `${left.replace(/\s*$/, '')}${right.replace(/^\s*/, '')}`
-    : left + right
-}
-
-const lines = (held: unknown, pad: string): readonly string[] => {
-  if (held === null || held === undefined) return [String(held)]
-  if (Array.isArray(held)) {
-    if (held.length === 0) return ['[]']
-    if (held.every((one) => typeof one !== 'object' || one === null)) return [held.map((one) => String(one)).join(', ')]
-    return held.flatMap((one) => {
-      const [first = '', ...rest] = lines(one, `${pad}  `)
-      return [`${pad}- ${first.trimStart()}`, ...rest]
-    })
-  }
-  if (typeof held === 'object') {
-    const parts = Object.entries(held as Record<string, unknown>)
-    if (parts.length === 0) return ['{}']
-    return parts.flatMap(([key, one]) => {
-      const [first = '', ...rest] = lines(one, `${pad}  `)
-      return rest.length === 0 && !first.includes('\n') ? [`${pad}${key}: ${first}`] : [`${pad}${key}:`, first, ...rest]
-    })
-  }
-  return [String(held)]
-}
-
-export function marked(parts: readonly string[]): string {
-  return createHash('sha256').update(parts.join('\n')).digest('hex').slice(0, 6)
-}
-
-export function showing(row: object, only: readonly string[] = []): string {
-  const held = row as Record<string, unknown>
-  const keys = Object.keys(held)
-
-  const wanted = only.filter((one) => one !== '')
-  const stray = wanted.filter((one) => !keys.includes(one))
-  if (stray.length > 0) {
-    return `${stray.map((one) => `\`${one}\``).join(', ')} ${stray.length === 1 ? 'is not a field' : 'are not fields'} of this row. It states ${keys.join(', ')}\n`
-  }
-
-  const showing = wanted.length === 0 ? keys : wanted
-  return `${showing.flatMap((key) => {
-    const [first = '', ...rest] = lines(held[key], '  ')
-    return rest.length === 0 ? [`${key}: ${first.trimStart()}`] : [`${key}:`, first, ...rest]
-  }).join('\n')}\n`
-}

package/dist/core/scope.ts

@@ -1,20 +0,0 @@
-export const ORGANISATION = '@prestack'
-
-export const THING = 'thread'
-
-export const NAMED = `${ORGANISATION}/${THING}`
-
-const CORE = 'core'
-
-const HEAD = `${NAMED}-`
-
-export const named = (id: string): string => (id === CORE ? NAMED : `${HEAD}${id}`)
-
-export const idOf = (name: string): string | undefined => {
-  if (name === NAMED) return CORE
-  return name.startsWith(HEAD) ? name.slice(HEAD.length) : undefined
-}
-
-export const ours = (name: string): boolean => idOf(name) !== undefined
-
-export const installed = (at: string): boolean => at.startsWith('node_modules/') && ours(at.split('/').slice(1, 3).join('/'))

package/dist/core/thread.ts

@@ -1,29 +0,0 @@
-export interface Quote {
-  readonly on: string
-  readonly said: string
-}
-
-export interface Threaded {
-  readonly id: string
-  readonly at: string
-  readonly describes: string
-  readonly version?: number
-  readonly cites?: readonly Quote[]
-  readonly requires?: readonly string[]
-  readonly takes?: readonly string[]
-  readonly by?: string
-  readonly runs?: string
-  readonly declares?: readonly Threaded[]
-  readonly derives?: readonly Threaded[]
-  readonly seeds?: readonly Threaded[]
-}
-
-export interface Member extends Threaded {
-  readonly version: number
-}
-
-export const PREFIXES = {
-  workflow: 'wf_',
-  view: 'vw_',
-  agent: 'agt_',
-} as const satisfies Readonly<Record<string, string>>

package/dist/core/tree.ts

@@ -1,90 +0,0 @@
-import { FOLDER, attached, existsSync, readdirSync, statSync } from '../integrations/disk.ts'
-import { dirname, join, relative, resolve } from 'node:path'
-import { cwd, env } from 'node:process'
-
-export { FOLDER }
-
-const NAMES = ['_threads', 'threads'] as const
-const ROOT = 'thread.ts'
-
-export interface Tree {
-  readonly at: string
-  readonly dir: string
-  readonly name: string
-  readonly root: string
-}
-
-export class UnthreadedRepositoryError extends Error {
-  constructor(from: string, floor?: string) {
-    super(
-      'no tree above ' + from + ' — looked for a ' + NAMES.map((one) => one + '/').join(' or ') + ' directory in every directory up to ' + (floor === undefined ? 'the filesystem root' : floor + ', the folder this was pointed at') + '. ' +
-        'Run `thread init` to write one.',
-    )
-    this.name = 'UnthreadedRepositoryError'
-  }
-}
-
-function given(): string {
-  const named = env[FOLDER]
-  return named === undefined ? '' : named
-}
-
-export function folder(): string {
-  const named = given()
-  if (named !== '') return resolve(named)
-  if (attached())
-    throw new Error(
-      'this is answering for a tree on another machine and nothing said which folder that is. ' +
-        FOLDER +
-        ' carries it and is not set here. Falling back to the folder this process was started in would read ' +
-        'the wrong tree and report it as yours, so it stopped instead.',
-    )
-  return cwd()
-}
-
-export function findTree(from: string = folder()): Tree {
-  const named = given()
-  const floor = attached() && named !== '' ? resolve(named) : undefined
-  let at = resolve(from)
-  for (;;) {
-    for (const name of NAMES) {
-      const dir = join(at, name)
-      if (existsSync(dir) && statSync(dir).isDirectory()) return { at, dir, name, root: join(dir, ROOT) }
-    }
-    const up = dirname(at)
-    if (up === at) throw new UnthreadedRepositoryError(from, floor)
-    if (at === floor) throw new UnthreadedRepositoryError(from, floor)
-    at = up
-  }
-}
-
-export function strayFiles(root: string, prefix: string, ends: string): readonly string[] {
-  const skip = new Set(['node_modules', '.git', '.next', 'dist', '_generated', 'coverage'])
-  const found: string[] = []
-  const walk = (dir: string): void => {
-
-    let held
-    try {
-      held = readdirSync(dir, { withFileTypes: true })
-    } catch {
-      return
-    }
-    for (const one of held) {
-      if (one.name.startsWith('.') || skip.has(one.name)) continue
-      const path = join(dir, one.name)
-      if (one.isDirectory()) {
-        walk(path)
-        continue
-      }
-      if (one.name.startsWith(prefix) && one.name.endsWith(ends)) {
-        found.push(relative(root, path).split('\\').join('/'))
-      }
-    }
-  }
-  walk(root)
-  return found.sort()
-}
-
-export function inTree(tree: Tree, file: string): string {
-  return join(tree.dir, file)
-}