@uknows/setup 0.1.0 → 0.2.0

package/lib/members.mjs

@@ -0,0 +1,269 @@
+/*
+ * The first-party code that 1 service builds with, and the local package files it uses. Static reading only.
+ *   Python: uv workspace members ({ workspace = true } in [tool.uv.sources]) and path sources, Poetry path dependencies.
+ *   Node.js: file:, link: and workspace: dependencies, and the packages of an npm, pnpm or yarn workspace.
+ *   .NET: ProjectReference items.
+ * Local packages: wheels, sdists, .tgz and .nupkg files the manifests name, and local NuGet sources.
+ */
+import { posix } from 'node:path'
+import { upFrom } from './workspace.mjs'
+import { pyName, tomlArray, tomlEntries, tomlInline, tomlString, tomlTable } from './toml.mjs'
+
+/**
+ * @typedef {Object} Member  A first-party package folder that the service depends on.
+ * @property {string} dir
+ * @property {string|null} name     Its package name ([project].name, package.json name or the csproj name).
+ * @property {string[]} manifests   Its manifest files.
+ * @property {string} file          The manifest that names it.
+ * @property {number} [line]
+ */
+/**
+ * @typedef {Object} LocalPackage  A package that comes from a file or folder in the repo, not from a registry.
+ * @property {string} name          The package name read from the file name, or the source folder.
+ * @property {string} path          Repo path of the file or folder.
+ * @property {'wheel'|'sdist'|'tgz'|'nupkg'|'source'|'folder'} kind
+ * @property {string} file          The file that names it.
+ * @property {number} [line]
+ */
+
+const MAX_MEMBERS = 50
+const join = (dir, file) => (dir === '.' ? file : `${dir}/${file}`)
+const dirOf = (path) => posix.dirname(path)
+const norm = (path) => posix.normalize(path).replace(/\/+$/, '') || '.'
+const read = (view, path) => { try { return view.read(path) } catch { return null } }
+const isUrl = (text) => /^[a-z][a-z0-9+.-]*:\/\//i.test(text)
+
+/**
+ * @param {import('./types.mjs').Service} service
+ * @param {import('./workspace.mjs').RepoView} view
+ * @returns {{members: Member[], local: LocalPackage[]}}
+ */
+export function findMembers(service, view) {
+  const members = [], local = [], seen = new Set([service.dir])
+  const addLocal = (entry) => { if (!local.some((l) => l.path === entry.path && l.file === entry.file)) local.push(entry) }
+  const queue = [service.dir]
+  const lang = service.lang
+  while (queue.length && members.length < MAX_MEMBERS) {
+    const dir = queue.shift()
+    const found = lang === 'python' ? python(dir, view) : lang === 'node' ? node(dir, view) : lang === 'dotnet' ? dotnet(dir, service, view) : { members: [], local: [] }
+    found.local.forEach(addLocal)
+    for (const m of found.members) {
+      if (seen.has(m.dir)) continue
+      seen.add(m.dir)
+      members.push(m)
+      queue.push(m.dir)
+    }
+  }
+  return { members, local }
+}
+
+/** The package name of the pyproject.toml in dir: [project].name, else [tool.poetry].name. */
+export function pythonProjectName(view, dir) {
+  const text = read(view, join(dir, 'pyproject.toml'))
+  const name = text && (tomlString(tomlTable(text, 'project'), 'name') ?? tomlString(tomlTable(text, 'tool.poetry'), 'name'))
+  return name ? pyName(name) : null
+}
+
+/** Workspaces found per view and root folder, so the members of 1 workspace walk the repo files once. */
+const WORKSPACES = new WeakMap()
+
+/** The nearest folder with a pyproject.toml that has [tool.uv.workspace], and its members: name -> dir. */
+export function uvWorkspace(view, dir) {
+  const cache = WORKSPACES.get(view) ?? WORKSPACES.set(view, new Map()).get(view)
+  for (const d of upFrom(dir, view.top ?? '.')) {
+    if (cache.has(d)) { if (cache.get(d)) return cache.get(d); continue }
+    const found = uvWorkspaceAt(view, d)
+    cache.set(d, found)
+    if (found) return found
+  }
+  return null
+}
+
+function uvWorkspaceAt(view, d) {
+  const text = read(view, join(d, 'pyproject.toml'))
+  if (!text || !/^\s*\[tool\.uv\.workspace\]/m.test(text)) return null
+  const table = tomlTable(text, 'tool.uv.workspace')
+  const include = tomlArray(table, 'members').map((g) => globRe(d, g)), exclude = tomlArray(table, 'exclude').map((g) => globRe(d, g))
+  const byName = new Map()
+  const add = (memberDir) => { const name = pythonProjectName(view, memberDir); if (name && !byName.has(name)) byName.set(name, memberDir) }
+  add(d)
+  for (const file of view.files().filter((f) => posix.basename(f) === 'pyproject.toml')) {
+    const memberDir = dirOf(file)
+    if (include.some((re) => re.test(memberDir)) && !exclude.some((re) => re.test(memberDir))) add(memberDir)
+  }
+  return { root: d, members: byName }
+}
+
+function python(dir, view) {
+  const out = { members: [], local: [] }
+  const file = join(dir, 'pyproject.toml'), text = read(view, file)
+  const workspace = () => (workspaceCache ??= uvWorkspace(view, dir))
+  let workspaceCache
+  const pathSource = (from, path, line, key) => {
+    const target = norm(posix.join(dirOf(from), path))
+    const kind = /\.whl$/i.test(target) ? 'wheel' : /\.(?:tar\.gz|zip)$/i.test(target) ? 'sdist' : null
+    if (kind) out.local.push({ name: packageName(posix.basename(target), kind) ?? key, path: target, kind, file: from, line })
+    else if (read(view, join(target, 'pyproject.toml')) !== null || read(view, join(target, 'setup.py')) !== null) {
+      out.members.push({ dir: target, name: pythonProjectName(view, target) ?? pyName(key), manifests: manifestsIn(view, target, 'python'), file: from, line })
+    } else out.local.push({ name: pyName(key), path: target, kind: 'folder', file: from, line })
+  }
+  if (text !== null) {
+    for (const { key, value, line } of tomlEntries(text, 'tool.uv.sources')) {
+      const source = tomlInline(value)
+      if (!source) continue
+      if (source.workspace === true) {
+        const memberDir = workspace()?.members.get(pyName(key))
+        if (memberDir && memberDir !== dir) out.members.push({ dir: memberDir, name: pyName(key), manifests: manifestsIn(view, memberDir, 'python'), file, line })
+      } else if (typeof source.path === 'string') pathSource(file, source.path, line, key)
+    }
+    const headers = [...text.matchAll(/^\s*\[(tool\.poetry(?:\.group\.[\w-]+)?\.(?:dev-)?dependencies)\]/gm)].map((m) => m[1])
+    for (const header of headers) {
+      for (const { key, value, line } of tomlEntries(text, header)) {
+        const source = tomlInline(value)
+        if (typeof source?.path === 'string') pathSource(file, source.path, line, key)
+      }
+    }
+  }
+  // requirements files: -e ./shared, ./vendor/x.whl, name @ file:///...
+  for (const name of view.list(dir).filter((n) => /^requirements[\w.-]*\.txt$/.test(n))) {
+    const req = join(dir, name)
+    ;(read(view, req) ?? '').split(/\r?\n/).forEach((raw, i) => {
+      const l = raw.replace(/(?:^|\s)#.*$/, '').trim()
+      const m = /^(?:-e\s+|--editable[=\s]+)?(?:[A-Za-z0-9._-]+\s*@\s*)?(?:file:(?:\/\/)?)?((?:\.{1,2}\/|[\w.-]+\/)[^\s;]*|[^\s;]+\.(?:whl|tar\.gz|zip))$/.exec(l)
+      if (m && !isUrl(m[1]) && !m[1].startsWith('/')) pathSource(req, m[1], i + 1, posix.basename(m[1]))
+    })
+  }
+  return out
+}
+
+function node(dir, view) {
+  const out = { members: [], local: [] }
+  const file = join(dir, 'package.json')
+  const text = read(view, file)
+  let pkg = null
+  try { pkg = JSON.parse(text ?? '') } catch { return out }
+  const lines = (text ?? '').split('\n')
+  const lineOf = (needle) => lines.findIndex((l) => l.includes(needle)) + 1 || undefined
+  let workspace
+  for (const group of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
+    for (const [name, spec] of Object.entries(pkg?.[group] ?? {})) {
+      if (typeof spec !== 'string') continue
+      const line = lineOf(JSON.stringify(name))
+      const path = /^(?:file|link|portal):(.+)$/.exec(spec)?.[1] ?? (/\.tgz$/.test(spec) && !isUrl(spec) ? spec : null)
+      if (path) {
+        const target = norm(posix.join(dir, path))
+        if (/\.tgz$/.test(target)) out.local.push({ name, path: target, kind: 'tgz', file, line })
+        else if (read(view, join(target, 'package.json')) !== null) out.members.push({ dir: target, name, manifests: [join(target, 'package.json')], file, line })
+        else out.local.push({ name, path: target, kind: 'folder', file, line })
+        continue
+      }
+      workspace ??= nodeWorkspace(view, dir)
+      const memberDir = workspace?.get(name)
+      if (memberDir && memberDir !== dir && (spec.startsWith('workspace:') || !isUrl(spec))) {
+        out.members.push({ dir: memberDir, name, manifests: [join(memberDir, 'package.json')], file, line })
+      }
+    }
+  }
+  return out
+}
+
+/** Packages of the npm, yarn or pnpm workspace around dir: name -> dir. null when there is none. */
+function nodeWorkspace(view, dir) {
+  for (const d of upFrom(dir, view.top ?? '.')) {
+    let globs = null
+    try {
+      const pkg = JSON.parse(read(view, join(d, 'package.json')) ?? '')
+      globs = Array.isArray(pkg?.workspaces) ? pkg.workspaces : Array.isArray(pkg?.workspaces?.packages) ? pkg.workspaces.packages : null
+    } catch { /* not JSON */ }
+    const pnpm = read(view, join(d, 'pnpm-workspace.yaml'))
+    if (!globs && pnpm) globs = [...pnpm.matchAll(/^\s*-\s*['"]?([^'"#\s]+)['"]?/gm)].map((m) => m[1]).filter((g) => !g.startsWith('!'))
+    if (!globs) continue
+    const res = globs.filter((g) => typeof g === 'string').map((g) => globRe(d, g))
+    const byName = new Map()
+    for (const f of view.files().filter((x) => posix.basename(x) === 'package.json')) {
+      if (!res.some((re) => re.test(dirOf(f)))) continue
+      try { const name = JSON.parse(read(view, f) ?? '')?.name; if (typeof name === 'string' && !byName.has(name)) byName.set(name, dirOf(f)) } catch { /* skip */ }
+    }
+    return byName
+  }
+  return null
+}
+
+function dotnet(dir, service, view) {
+  const out = { members: [], local: [] }
+  const projects = dir === service.dir ? service.manifests.filter((m) => m.endsWith('.csproj')) : view.list(dir).filter((n) => n.endsWith('.csproj')).map((n) => join(dir, n))
+  for (const csproj of projects) {
+    const text = read(view, csproj) ?? ''
+    const lines = text.split('\n')
+    for (const m of text.matchAll(/<ProjectReference\s[^>]*?Include\s*=\s*"([^"]+)"/gi)) {
+      const target = norm(posix.join(dirOf(csproj), m[1].replace(/\\/g, '/')))
+      if (read(view, target) === null) continue
+      out.members.push({ dir: dirOf(target), name: posix.basename(target).replace(/\.csproj$/i, ''), manifests: [target], file: csproj,
+        line: lines.findIndex((l) => l.includes(m[0])) + 1 || undefined })
+    }
+    if (dir === service.dir) out.local.push(...nugetSources(view, csproj))
+  }
+  return out
+}
+
+/** Local NuGet sources for 1 project: NuGet.Config files up the tree and RestoreAdditionalProjectSources, with the .nupkg files in them. */
+function nugetSources(view, csproj) {
+  const out = []
+  const add = (from, value, line) => {
+    for (const part of value.split(';').map((p) => p.trim()).filter(Boolean)) {
+      if (isUrl(part) || /^[A-Za-z]:/.test(part) || part.startsWith('/')) continue
+      const path = norm(posix.join(dirOf(from), part.replace(/\$\(MSBuild(?:ThisFileDirectory|ProjectDirectory)\)/g, '').replace(/\\/g, '/')))
+      if (path.startsWith('..') && !(view.top ?? '.').startsWith('..')) continue
+      out.push({ name: posix.basename(path), path, kind: 'source', file: from, line })
+      for (const name of safeList(view, path).filter((n) => /\.nupkg$/i.test(n))) {
+        out.push({ name: packageName(name, 'nupkg'), path: join(path, name), kind: 'nupkg', file: from, line })
+      }
+    }
+  }
+  for (const d of upFrom(dirOf(csproj), view.top ?? '.')) {
+    for (const name of safeList(view, d).filter((n) => /^nuget\.config$/i.test(n) || n === 'Directory.Build.props')) {
+      const file = join(d, name), text = read(view, file) ?? ''
+      let sources = false
+      text.split('\n').forEach((l, i) => {
+        if (/<packageSources\b/i.test(l)) sources = !/\/>\s*$/.test(l)
+        const source = /<add\s[^>]*?value\s*=\s*"([^"]+)"/i.exec(l)
+        if (sources && /nuget\.config$/i.test(name) && source) add(file, source[1], i + 1)
+        if (/<\/packageSources>/i.test(l)) sources = false
+        const restore = /<Restore(?:Additional)?(?:Project)?Sources>([^<]+)</i.exec(l)
+        if (restore) add(file, restore[1], i + 1)
+      })
+    }
+  }
+  ;(read(view, csproj) ?? '').split('\n').forEach((l, i) => {
+    const restore = /<Restore(?:Additional)?(?:Project)?Sources>([^<]+)</i.exec(l)
+    if (restore) add(csproj, restore[1], i + 1)
+  })
+  return out
+}
+
+function safeList(view, dir) {
+  try { return view.list ? view.list(dir) : [] } catch { return [] }
+}
+
+/** The manifests of a member folder. */
+function manifestsIn(view, dir, lang) {
+  const names = safeList(view, dir)
+  if (lang === 'python') return names.filter((n) => n === 'pyproject.toml' || /^requirements[\w.-]*\.txt$/.test(n)).map((n) => join(dir, n)).sort()
+  return []
+}
+
+/** A folder glob of a workspace (packages/*, app) as a test for repo folders. */
+function globRe(base, glob) {
+  const path = norm(posix.join(base, glob.replace(/\/+$/, '')))
+  const re = path.split('/').map((part) => (part === '**' ? '.*' : part.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]')))
+  return new RegExp(`^${re.join('/')}$`)
+}
+
+/** The package name in a wheel, sdist, .tgz or .nupkg file name. */
+export function packageName(file, kind) {
+  if (kind === 'wheel') return pyName(file.split('-')[0])
+  if (kind === 'sdist') return pyName(file.replace(/-\d[^-]*\.(?:tar\.gz|zip)$/i, ''))
+  if (kind === 'tgz') return file.replace(/-\d[\w.+-]*\.tgz$/, '').replace(/\.tgz$/, '')
+  if (kind === 'nupkg') return file.replace(/\.\d+(?:\.\d+)*(?:-[\w.-]+)?\.nupkg$/i, '').replace(/\.nupkg$/i, '')
+  return file
+}

package/lib/plan.mjs

@@ -0,0 +1,130 @@
+/*
+ * The plan of a run with 1 Yes, as the person reads it: what setup found, the files it changes (with how many lines),
+ * where the key goes, the deploy file edits, the branch and the pull request, and the link to watch the app connect.
+ * Then 1 question, and a tidy list of the steps as they run. Text only: the engine gathers the facts and does the work.
+ */
+import { CLI } from './contract.mjs'
+import { countLines, splitLines } from './diff.mjs'
+import { list, plural, wrap } from './ui.mjs'
+
+/** The question of a run with 1 Yes. */
+export const ONE_YES = 'Do all of this? (Y/n)'
+
+const LOCKFILES = new Set(['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'uv.lock', 'poetry.lock', 'pdm.lock', 'packages.lock.json'])
+
+/** "8 lines added", "1 line removed", "2 lines added, 1 removed". */
+function linesWord(added, removed) {
+  if (!removed) return `${plural(added, 'line')} added`
+  if (!added) return `${plural(removed, 'line')} removed`
+  return `${plural(added, 'line')} added, ${removed} removed`
+}
+
+/**
+ * The files of the plan, as [file, what changes]: the edits with their line counts, the files that a package manager
+ * writes, and the record. manifest: the record exists already.
+ */
+export function fileRows(changes, commands, { manifest = false } = {}) {
+  const rows = new Map()
+  for (const c of changes) {
+    if (c.before === null) rows.set(c.file, `new file, ${plural(splitLines(c.after).length, 'line')}`)
+    else { const { added, removed } = countLines(c.before, c.after); rows.set(c.file, linesWord(added, removed)) }
+  }
+  for (const c of commands) {
+    for (const file of c.touches) {
+      const what = c.kind === 'lock' ? `${c.cmd} ${c.args[0]} updates it` : LOCKFILES.has(file.split('/').pop()) ? `${c.cmd} updates it`
+        : `${c.cmd} adds ${plural(c.added?.length ?? 0, 'package')}`
+      rows.set(file, rows.has(file) ? `${rows.get(file)}, and ${what}` : what)
+    }
+  }
+  rows.set(CLI.manifest, `${manifest ? 'updated' : 'new file'}, so npx @uknows/setup remove can undo this`)
+  return [...rows]
+}
+
+const pad = (text, width) => `${text}${' '.repeat(Math.max(2, width - text.length))}`
+
+/**
+ * Label and value rows, the values in 1 column, long values wrapped under their column. The column fits a label of 38
+ * characters, such as .github/workflows/uknows-updates.yml, so the rows of a plan stay in line.
+ */
+function rows(ui, items, indent) {
+  if (!items.length) return
+  const width = Math.min(Math.max(...items.map(([label]) => label.length)) + 2, 40)
+  const room = Math.max(24, ui.columns() - indent.length - width)
+  for (const [label, value] of items) {
+    wrap(value, room).forEach((line, i) => ui.print(`${indent}${i ? ' '.repeat(width) : ui.dim(pad(label, width))}${line}`))
+  }
+}
+
+/**
+ * Print the plan. plan: {
+ *   app: [label, value] rows (App, Runs on, Sends to), nameNote,
+ *   steps: [{title, rows: [[label, value]], notes: [text]}],
+ *   then: text (what the person does after), byHand: [titles], good: [notes]
+ * }
+ */
+export function printPlan(ui, plan) {
+  ui.print(ui.bold('Here is the plan'))
+  rows(ui, plan.app, '  ')
+  if (plan.nameNote) ui.say(ui.dim(plan.nameNote), '  ')
+  plan.steps.forEach((step, i) => {
+    ui.print()
+    ui.say(ui.bold(`${i + 1}. ${step.title}`), '  ', '     ')
+    rows(ui, step.rows ?? [], '     ')
+    for (const note of step.notes ?? []) ui.say(note, '     ')
+  })
+  if (plan.byHand?.length) {
+    ui.print()
+    ui.say(`${ui.bold('Left for you')} ${ui.dim(`(${plan.byHand.length === 1 ? 'the step prints' : 'the steps print'} at the end)`)}`, '  ')
+    for (const title of plan.byHand) ui.say(title, '     ', '  ')
+  }
+  if (plan.good?.length) {
+    ui.print()
+    ui.say(ui.bold('Good to know'), '  ')
+    for (const note of plan.good) ui.say(note, '     ')
+  }
+  if (plan.then) {
+    ui.print()
+    ui.say(plan.then, '  ')
+  }
+  ui.print()
+}
+
+/**
+ * The 1 question. d shows every line that changes, then asks again. Enter or y: true. n or the end of the input: false.
+ * diff(): the lines to show for d.
+ */
+export async function askOnce(ui, diff) {
+  ui.print(ui.dim('Type d to see every line that changes.'))
+  for (let tries = 0; tries < 5; tries++) {
+    const answer = await ui.line(ONE_YES)
+    if (answer === null) return false
+    const a = answer.toLowerCase()
+    if (a === '' || a === 'y' || a === 'yes') return true
+    if (a === 'n' || a === 'no') return false
+    if (a === 'd') {
+      ui.print()
+      for (const line of diff()) ui.print(line)
+      ui.print()
+      continue
+    }
+    ui.print('Type y, n or d.')
+  }
+  return false
+}
+
+/**
+ * 1 step of the list: a spinner with doing while run() works, then 1 line with done or failed. run() returns
+ * {ok, line, more}: more are lines under it (what to do next). A thrown error counts as failed.
+ */
+export async function step(ui, doing, run) {
+  const p = ui.progress(doing, '  ')
+  let r
+  try {
+    r = await run()
+  } catch (error) {
+    r = { ok: false, line: `${doing}: ${error.message}` }
+  }
+  p.end(`  ${r.ok ? ui.cyan(ui.marks.done) : ui.red(ui.marks.failed)} ${r.line}`)
+  for (const line of r.more ?? []) ui.say(line, '    ', '  ')
+  return r
+}