@prestack/thread 0.1.20 → 0.1.22

package/dist/core/generators/commit.ts

@@ -1,157 +0,0 @@
-import { createHash } from 'node:crypto'
-import { deflateSync, inflateSync } from 'node:zlib'
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs'
-import { join, relative, sep } from 'node:path'
-import { argv, cwd, stdout, stderr } from 'node:process'
-
-const dir = cwd()
-const message = (argv[2] ?? 'thread').slice(0, 400)
-const NL = String.fromCharCode(10)
-const NUL = String.fromCharCode(0)
-const SLASH = String.fromCharCode(47)
-const matches = (pat: string, name: string): boolean => {
-  const parts = pat.split('*')
-  if (parts.length === 1) return name === pat
-  const first = parts[0]
-  if (!name.startsWith(first)) return false
-  let at = first.length
-  for (let k = 1; k < parts.length - 1; k += 1) {
-    const found = name.indexOf(parts[k], at)
-    if (found === -1) return false
-    at = found + parts[k].length
-  }
-  const last = parts[parts.length - 1]
-  return name.length - last.length >= at && name.endsWith(last)
-}
-
-interface Ignore {
-  readonly negate: boolean
-  readonly dirOnly: boolean
-  readonly anchored: boolean
-  readonly pat: string
-}
-
-let text = ''
-try {
-  text = readFileSync(join(dir, '.gitignore'), 'utf8')
-} catch {
-  text = ''
-}
-const patterns: Ignore[] = []
-for (const raw of text.split(NL)) {
-  let line = raw.trim()
-  if (line === '' || line.startsWith('#')) continue
-  const negate = line.startsWith('!')
-  if (negate) line = line.slice(1)
-  const dirOnly = line.endsWith(SLASH)
-  if (dirOnly) line = line.slice(0, -1)
-  let anchored = line.startsWith(SLASH)
-  if (anchored) line = line.slice(1)
-  if (line.includes(SLASH)) anchored = true
-  if (line !== '') patterns.push({ negate, dirOnly, anchored, pat: line })
-}
-
-const ignored = (rel: string, name: string, isDir: boolean): boolean => {
-  if (name === '.git') return true
-  let hit = false
-  for (const one of patterns) {
-    if (one.dirOnly && !isDir) continue
-    if (matches(one.pat, one.anchored ? rel : name)) hit = !one.negate
-  }
-  return hit
-}
-const BRANCH = ['refs', 'heads', 'main'].join(SLASH)
-
-interface Entry {
-  readonly mode: string
-  readonly name: string
-  readonly sha: string
-}
-
-const store = (kind: string, body: Buffer): string => {
-  const whole = Buffer.concat([Buffer.from(kind + ' ' + String(body.length) + NUL), body])
-  const sha = createHash('sha1').update(whole).digest('hex')
-  const at = join(dir, '.git', 'objects', sha.slice(0, 2), sha.slice(2))
-  if (!existsSync(at)) {
-    mkdirSync(join(dir, '.git', 'objects', sha.slice(0, 2)), { recursive: true })
-    writeFileSync(at, deflateSync(whole))
-  }
-  return sha
-}
-
-const tree = (at: string): string => {
-  const entries: Entry[] = []
-  for (const name of readdirSync(at)) {
-    const full = join(at, name)
-    const stat = statSync(full)
-    const rel = relative(dir, full).split(sep).join(SLASH)
-    if (ignored(rel, name, stat.isDirectory())) continue
-    if (stat.isDirectory()) {
-      const sub = tree(full)
-      if (sub !== '') entries.push({ mode: '40000', name, sha: sub })
-    } else if (stat.isFile()) {
-      const sha = store('blob', readFileSync(full))
-      entries.push({ mode: (stat.mode & 0o111) !== 0 ? '100755' : '100644', name, sha })
-    }
-  }
-  if (entries.length === 0) return ''
-  const key = (one: Entry): string => one.name + (one.mode === '40000' ? SLASH : '')
-  entries.sort((one, two) => (key(one) < key(two) ? -1 : key(one) > key(two) ? 1 : 0))
-  const body = Buffer.concat(
-    entries.map((one) => Buffer.concat([Buffer.from(one.mode + ' ' + one.name + NUL), Buffer.from(one.sha, 'hex')])),
-  )
-  return store('tree', body)
-}
-
-const treeOf = (sha: string): string => {
-  const at = join(dir, '.git', 'objects', sha.slice(0, 2), sha.slice(2))
-  const raw = inflateSync(readFileSync(at))
-  const body = raw.slice(raw.indexOf(0) + 1).toString('utf8')
-  const first = body.split(NL)[0] ?? ''
-  return first.startsWith('tree ') ? first.slice(5) : ''
-}
-
-const record = (): void => {
-  const gitDir = join(dir, '.git')
-  if (!existsSync(join(gitDir, 'HEAD'))) {
-    mkdirSync(join(gitDir, 'objects'), { recursive: true })
-    mkdirSync(join(gitDir, 'refs', 'heads'), { recursive: true })
-    writeFileSync(join(gitDir, 'HEAD'), 'ref: ' + BRANCH + NL)
-  }
-  const head = readFileSync(join(gitDir, 'HEAD'), 'utf8').trim()
-  const ref = head.startsWith('ref: ') ? head.slice(5) : BRANCH
-  const refAt = join(gitDir, ref)
-  const parent = existsSync(refAt) ? readFileSync(refAt, 'utf8').trim() : ''
-
-  const root = tree(dir)
-  if (root === '') {
-    stdout.write('commit: nothing to commit' + NL)
-    return
-  }
-  if (parent !== '' && treeOf(parent) === root) {
-    stdout.write('commit: nothing changed' + NL)
-    return
-  }
-
-  const when = String(Math.floor(Date.now() / 1000)) + ' +0000'
-  const who = 'thread <thread@prestack> ' + when
-  const body = [
-    'tree ' + root,
-    ...(parent === '' ? [] : ['parent ' + parent]),
-    'author ' + who,
-    'committer ' + who,
-    '',
-    message,
-    '',
-  ].join(NL)
-  const sha = store('commit', Buffer.from(body))
-  writeFileSync(refAt, sha + NL)
-  stdout.write('commit: ' + sha.slice(0, 8) + ' on ' + (ref.split(SLASH).pop() ?? 'main') + NL)
-}
-
-try {
-  record()
-} catch (thrown) {
-  stderr.write('commit: ' + (thrown instanceof Error ? thrown.message : String(thrown)) + NL)
-  process.exit(1)
-}

package/dist/core/init.ts

@@ -1,222 +0,0 @@
-import { LOCKFILES, installing, manager } from '../integrations/cli.ts'
-import { existsSync, readFileSync, writeFileSync } from '../integrations/disk.ts'
-import { createRequire } from 'node:module'
-import { join, relative, resolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { quoted } from './rows.ts'
-import { NAMED } from './scope.ts'
-
-
-export const TREE = '_threads'
-export const ROOT = 'thread.ts'
-
-export const SHAPED = `${NAMED}/core/thread`
-
-export class AlreadyThreadedError extends Error {
-  readonly at: string
-  constructor(at: string) {
-    super(
-
-      `${at} already exists, so this repository already has a root. A tree has one root and it is written once. ` +
-        'Declare something under it with `thread create` — run it bare to see what this tree makes — or take on ' +
-        'a package with `thread attach`, which brings its rows with it. Neither is written by hand.',
-    )
-    this.name = 'AlreadyThreadedError'
-    this.at = at
-  }
-}
-
-export const COMPILER = 'tsconfig.json'
-
-export const MANIFEST = 'package.json'
-
-const BUILT = '_gener' + 'ated/packages/core'
-
-const MODULE = 'module'
-
-const NPM = 'npm'
-
-const LATEST = 'latest'
-
-export const REGISTRY = '.npm' + 'rc'
-
-export const IGNORED = '.git' + 'ignore'
-
-export function ignored(): string {
-  return [
-    'node_' + 'modules/',
-    '.next/',
-    'dist/',
-
-    '*.tsbuildinfo',
-
-    'next-env.d.ts',
-    '.DS_Store',
-    '',
-  ].join('\n')
-}
-
-export function compiler(): string {
-  return `${JSON.stringify(
-    {
-      compilerOptions: {
-        target: 'ES2022',
-        module: 'ESNext',
-        moduleResolution: 'bundler',
-        strict: true,
-
-        allowImportingTsExtensions: true,
-
-        skipLibCheck: true,
-
-        types: ['node'],
-        jsx: 'react-jsx',
-        noEmit: true,
-      },
-    },
-    null,
-    2,
-  )}\n`
-}
-
-function owned(into: string): readonly { readonly id: string; readonly at: string; readonly describes: string; readonly runs?: string }[] {
-  const held = Object.keys(LOCKFILES).filter((one) => existsSync(join(into, one)))
-  return [
-    {
-      id: 'manifest',
-      at: 'package.json',
-      describes:
-        'What this app is made of and what may be run against it — the packages it installs and the commands that build it, serve it and refuse it.',
-    },
-
-    ...(existsSync(join(into, REGISTRY))
-      ? [
-          {
-            id: 'registry',
-            at: REGISTRY,
-            describes:
-              'Which registry this app’s packages come from, and any credential scoped to it. Declared beside the lockfile because an install is not reproducible without it: the lockfile says which versions answered, and this says who answered.',
-          },
-        ]
-      : []),
-    {
-      id: 'ignored',
-      at: IGNORED,
-      describes:
-        'What is built rather than written, so the checks that read this repository can tell the two apart. Every surface here asks which files are tracked, and without it an app that has been served once answers with its whole build cache.',
-    },
-    ...held.map((one) => ({
-      id: 'lockfile',
-      at: one,
-      describes:
-        'The exact version of every package this app resolved to, so an install here and an install anywhere else are the same install.',
-    })),
-  ]
-}
-
-export function root(into: string): string {
-  const rows = owned(into).flatMap((one) => [
-    '    {',
-    `      id: ${quoted(one.id)},`,
-    `      at: ${quoted(one.at)},`,
-    `      describes: ${quoted(one.describes)},`,
-    '      version: 1,',
-    ...(one.runs === undefined ? [] : [`      runs: ${quoted(one.runs)},`]),
-    '    },',
-  ])
-  return [
-    `import type { Threaded } from '${SHAPED}'`,
-    '',
-    'export const THREAD: Threaded = {',
-    "  id: 'thread',",
-    `  at: '${TREE}/${ROOT}',`,
-    "  describes: 'The framework that declares what must exist, forbids what is not declared, and derives what can be derived.',",
-    '  version: 1,',
-    '  declares: [',
-    ...rows,
-    '  ],',
-    '}',
-    '',
-  ].join('\n')
-}
-
-const own = createRequire(import.meta.url)
-
-function manifested(at: string): { readonly name?: string; readonly version?: string } | undefined {
-  try {
-    return own(at) as { readonly name?: string; readonly version?: string }
-  } catch {
-    return undefined
-  }
-}
-
-function shipped(): readonly [string, string] {
-  let at = fileURLToPath(new URL('.', import.meta.url))
-  for (;;) {
-    const read = manifested(join(at, MANIFEST))
-    if (read !== undefined) {
-      if (read.name !== undefined && read.version !== undefined) return [read.name, read.version]
-      const core = manifested(join(at, BUILT, MANIFEST))
-      if (core?.name !== undefined && core.version !== undefined) return [core.name, core.version]
-    }
-    const up = resolve(at, '..')
-    if (up === at) {
-      throw new Error(
-        'this framework cannot find the package it is running from, so it has no name to install into your project. ' +
-          'That name is read off the manifest beside this code rather than written down anywhere, which is what keeps it ' +
-          'right when the package is renamed.',
-      )
-    }
-    at = up
-  }
-}
-
-export function init(into: string): readonly string[] {
-  const dir = resolve(into, TREE)
-  const at = join(dir, ROOT)
-  if (existsSync(at)) throw new AlreadyThreadedError(relative(into, at))
-  const written: string[] = []
-
-  const held = join(into, COMPILER)
-  if (!existsSync(held)) {
-    writeFileSync(held, compiler(), 'utf8')
-    written.push(COMPILER)
-  }
-
-  const manifest = join(into, MANIFEST)
-  if (!existsSync(manifest)) {
-    const called = (into.split('/').filter(Boolean).pop() ?? 'app').toLowerCase().replace(/[^a-z0-9-]+/g, '-')
-    writeFileSync(manifest, JSON.stringify({ name: called, version: '0.0.0', type: MODULE }, null, 2) + '\n', 'utf8')
-    written.push(MANIFEST)
-  }
-  const stated = JSON.parse(readFileSync(manifest, 'utf8')) as { type?: string }
-  if (stated.type !== MODULE) {
-    writeFileSync(manifest, `${JSON.stringify({ ...stated, type: MODULE }, null, 2)}\n`, 'utf8')
-    written.push(MANIFEST)
-  }
-
-  const [from, version] = shipped()
-  const holds = JSON.parse(readFileSync(manifest, 'utf8')) as { devDependencies?: Record<string, string> }
-  const dev = holds.devDependencies ?? {}
-  const wanted: Readonly<Record<string, string>> = { [from]: '^' + version, ...(manager(into) === NPM ? { [NPM]: LATEST } : {}) }
-  const missing = Object.entries(wanted).filter(([name]) => dev[name] === undefined)
-  if (missing.length > 0) {
-    writeFileSync(manifest, JSON.stringify({ ...holds, devDependencies: { ...dev, ...Object.fromEntries(missing) } }, null, 2) + '\n', 'utf8')
-    written.push(MANIFEST)
-  }
-
-  const ignore = join(into, IGNORED)
-  if (!existsSync(ignore)) {
-    writeFileSync(ignore, ignored(), 'utf8')
-    written.push(IGNORED)
-  }
-
-  installing(into)
-
-  for (const [name, text] of [[ROOT, root(into)]] as const) {
-    writeFileSync(join(dir, name), text, 'utf8')
-    written.push(relative(into, join(dir, name)))
-  }
-  return written
-}

package/dist/core/invoked.ts

@@ -1,52 +0,0 @@
-import { dirname, join } from 'node:path'
-import { argv, exit as ending } from 'node:process'
-import { fileURLToPath } from 'node:url'
-
-import { realpathSync } from '../integrations/disk.ts'
-
-export function invoked(url: string): boolean {
-  const named = argv[1]
-  if (named === undefined) return false
-  try {
-    const held = new URL(url)
-    held.search = ''
-    held.hash = ''
-    return realpathSync(named) === realpathSync(fileURLToPath(held))
-  } catch {
-    return false
-  }
-}
-
-export const SOURCE = import.meta.url.endsWith('.ts')
-
-export const BESIDE = (name: string): string => `${name}${SOURCE ? '.ts' : '.js'}`
-
-export const BUILT = (at: string): string => (SOURCE ? at : at.replace(/\.tsx?$/, '.js'))
-
-export const LOADER: readonly string[] = SOURCE ? ['--import', 'tsx'] : []
-
-export const CLI: readonly string[] = [
-  ...LOADER,
-  join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'cli', BESIDE('cli')),
-]
-
-export const REFUSED = Symbol.for('thread.refused')
-
-let sharing = false
-
-export const shared = (on: boolean): boolean => {
-  const was = sharing
-  sharing = on
-  return was
-}
-
-export function exit(code?: number): never {
-  if (!sharing) ending(code)
-  throw Object.assign(new Error(`refused with ${String(code ?? 0)}`), { [REFUSED]: code ?? 0 })
-}
-
-export const refusal = (thrown: unknown): number | undefined => {
-  if (typeof thrown !== 'object' || thrown === null) return undefined
-  const held = (thrown as Record<symbol, unknown>)[REFUSED]
-  return typeof held === 'number' ? held : undefined
-}

package/dist/core/round.ts

@@ -1,74 +0,0 @@
-import { resolve } from 'node:path'
-import { argv, exitCode, stderr, stdout } from 'node:process'
-import { pathToFileURL } from 'node:url'
-
-import { generators, RAN, REFUSED_BY } from './chain.ts'
-import { attached, here } from '../integrations/disk.ts'
-import { forget } from './descend.ts'
-import { refusal, shared } from './invoked.ts'
-import { findTree } from './tree.ts'
-
-let spun = 0
-
-const words = (command: string): readonly string[] => command.trim().split(/\s+/).slice(1)
-
-shared(true)
-
-const tree = findTree()
-const rows = await generators(tree)
-
-let stale = true
-
-for (const command of argv.slice(2).filter((one) => one !== '')) {
-  const said = words(command)
-  const name = said[0]
-  if (name === undefined) continue
-
-  const held = rows.find((one) => one.by === `thread ${name}`)
-  if (held?.at === undefined) {
-    stdout.write(`round: no command named "${name}", so \`${command}\` was not run\n`)
-    stdout.write(`${REFUSED_BY} ${command}\n`)
-    continue
-  }
-
-  const found = resolve(tree.at, held.at)
-
-  if (stale) forget()
-
-  argv.length = 1
-  argv.push(found, ...said.slice(1))
-
-  spun += 1
-
-  process.exitCode = 0
-
-  const began = Date.now()
-  stderr.write(`settle: running ${command}\n`)
-
-  let ok = true
-  const ran = attached() ? here().run(found, said.slice(1)) : undefined
-  if (ran !== undefined) {
-    stdout.write(ran.out)
-    stderr.write(ran.err)
-    ok = ran.there && ran.ok
-    if (!ran.there) stdout.write('round: ' + command + ' could not be started where the tree is: ' + ran.why + '\n')
-  } else {
-  try {
-    await import(`${pathToFileURL(found).href}?round=${String(spun)}`)
-    ok = exitCode === undefined || exitCode === 0
-  } catch (thrown) {
-    const code = refusal(thrown)
-    if (code === undefined) {
-      ok = false
-      stdout.write(`round: \`${command}\` threw: ${thrown instanceof Error ? thrown.message : String(thrown)}\n`)
-    } else ok = code === 0
-  }
-  }
-
-  stdout.write(`${ok ? RAN : REFUSED_BY} ${command}\n`)
-  stderr.write(`settle: ${command} — ${String(Date.now() - began)} ms, ${ok ? 'ran' : 'refused'}\n`)
-
-  stale = !command.trim().endsWith('--check')
-}
-
-process.exitCode = 0