@10stars/config 17.0.3 → 17.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10stars/config",
-  "version": "17.0.3",
+  "version": "17.0.4",
   "private": false,
   "bin": {
     "config": "./src/index.ts"

package/src/link-remote.ts

@@ -1,6 +1,7 @@
-import { execFileSync } from "node:child_process"
+import { execFile, execFileSync } from "node:child_process"
 import fs from "node:fs/promises"
 import path from "node:path"
+import { promisify } from "node:util"
 
 import type * as TF from "type-fest"
 
@@ -39,9 +40,14 @@ type Sibling = { abs: string; ref: string | null }
 const git = (args: string[], cwd?: string): string =>
   execFileSync(`git`, args, { cwd, encoding: `utf8` }).trim()
 
-const gitInherit = (args: string[], cwd?: string): void => {
-  execFileSync(`git`, args, { cwd, stdio: `inherit` })
-}
+const execFileAsync = promisify(execFile)
+
+// Async git so independent clones (a BFS level's siblings, or all pinned --from clones) run
+// concurrently: the sync `git` helper's execFileSync would serialize them by blocking the event
+// loop until each finishes. Output is captured (not inherited) so concurrent progress can't
+// interleave into unreadable logs; callers log one line per repo.
+const gitAsync = (args: string[], cwd?: string): Promise<unknown> =>
+  execFileAsync(`git`, args, { cwd })
 
 const tryGit = (args: string[], cwd?: string): string | null => {
   try {
@@ -107,22 +113,34 @@ const fileSiblingRoots = async (dir: string): Promise<string[]> => {
 }
 
 /**
- * BFS the transitive `file:` sibling graph from `cwd`, invoking `visit` once per newly discovered
- * sibling root in dependents-first order. Cloning inside `visit` makes that sibling's own `file:`
- * deps discoverable when it is later dequeued; a still-missing dir simply yields no children.
+ * BFS the transitive `file:` sibling graph from `cwd` in dependents-first order, invoking `visit`
+ * on each level's newly discovered siblings concurrently (`Promise.all`). Cloning a sibling in
+ * `visit` makes its own `file:` deps discoverable when the next level expands from it. Levels stay
+ * sequential (a child is only found after its parent is cloned) but siblings within a level are
+ * independent and clone in parallel. The `visited` set dedupes repos reached by more than one path,
+ * both across and within a level. Returns the deduped siblings in discovery (dependents-first) order.
  */
-const bfsSiblings = async (cwd: string, visit: (sib: string) => Promise<void>): Promise<void> => {
+const bfsSiblings = async (
+  cwd: string,
+  visit: (sib: string) => Promise<void>,
+): Promise<string[]> => {
   const visited = new Set<string>([path.resolve(cwd)])
-  const queue = [path.resolve(cwd)]
-  while (queue.length) {
-    const dir = queue.shift()!
-    for (const sib of await fileSiblingRoots(dir)) {
-      if (visited.has(sib)) continue
-      visited.add(sib)
-      await visit(sib)
-      queue.push(sib)
+  const order: string[] = []
+  let frontier = [path.resolve(cwd)]
+  while (frontier.length) {
+    const level: string[] = []
+    for (const dir of frontier) {
+      for (const sib of await fileSiblingRoots(dir)) {
+        if (visited.has(sib)) continue // dedupe repos reached via multiple file: paths
+        visited.add(sib)
+        level.push(sib)
+      }
     }
+    await Promise.all(level.map(visit)) // clone this level's siblings in parallel
+    order.push(...level)
+    frontier = level
   }
+  return order
 }
 
 /**
@@ -160,7 +178,12 @@ const matchRemoteBranch = (url: string, candidates: string[]): string | null =>
  * `--branch`, so the `ls-remote` probe is skipped entirely when no coordinated branch is set — one
  * fewer round-trip for local/manual runs (in GitHub Actions GITHUB_REF_NAME is always set).
  */
-const cloneSibling = (url: string, repo: string, sib: string, dest: string): string | null => {
+const cloneSibling = async (
+  url: string,
+  repo: string,
+  sib: string,
+  dest: string,
+): Promise<string | null> => {
   const coordinated = [
     process.env.GITHUB_HEAD_REF, // pull_request events
     process.env.GITHUB_REF_NAME, // push events
@@ -168,7 +191,7 @@ const cloneSibling = (url: string, repo: string, sib: string, dest: string): str
   const ref = coordinated.length ? matchRemoteBranch(url, coordinated) : null
 
   console.info(`linkRemote: cloning ${repo}@${ref ?? `(default)`} -> ${dest}`)
-  gitInherit([
+  await gitAsync([
     `clone`,
     `--depth`,
     `1`,
@@ -189,11 +212,11 @@ const currentRef = (dir: string): string | null => {
   return branch === `HEAD` ? null : branch
 }
 
-const clonePinned = (url: string, sha: string, dir: string): void => {
-  gitInherit([`init`, dir])
-  gitInherit([`remote`, `add`, `origin`, url], dir)
-  gitInherit([`fetch`, `--depth`, `1`, `origin`, sha], dir) // GitHub allows fetching a reachable SHA
-  gitInherit([`checkout`, `FETCH_HEAD`], dir)
+const clonePinned = async (url: string, sha: string, dir: string): Promise<void> => {
+  await gitAsync([`init`, dir])
+  await gitAsync([`remote`, `add`, `origin`, url], dir)
+  await gitAsync([`fetch`, `--depth`, `1`, `origin`, sha], dir) // GitHub allows fetching a reachable SHA
+  await gitAsync([`checkout`, `FETCH_HEAD`], dir)
 }
 
 /**
@@ -201,19 +224,18 @@ const clonePinned = (url: string, sha: string, dir: string): void => {
  * Returns siblings in discovery (BFS) order — dependents before their dependencies.
  */
 const cloneClosureBranchFirst = async (cwd: string): Promise<Sibling[]> => {
-  const order: Sibling[] = []
-  await bfsSiblings(cwd, async (sib) => {
-    let ref: string | null
+  // Parallel visits resolve out of order; key refs by abs path and reassemble in discovery order.
+  const refs = new Map<string, string | null>()
+  const discovered = await bfsSiblings(cwd, async (sib) => {
     if (await exists(sib)) {
       console.info(`linkRemote: ${path.relative(cwd, sib)} already present; not cloning`)
-      ref = currentRef(sib)
-    } else {
-      const repo = path.basename(sib)
-      ref = cloneSibling(repoUrl(repo), repo, sib, path.relative(cwd, sib))
+      refs.set(sib, currentRef(sib))
+      return
     }
-    order.push({ abs: sib, ref })
+    const repo = path.basename(sib)
+    refs.set(sib, await cloneSibling(repoUrl(repo), repo, sib, path.relative(cwd, sib)))
   })
-  return order
+  return discovered.map((abs) => ({ abs, ref: refs.get(abs) ?? null }))
 }
 
 const writeManifest = async (cwd: string, siblings: Sibling[], out: string): Promise<void> => {
@@ -244,16 +266,20 @@ const linkRemoteFromManifest = async (cwd: string, manifestPath: string): Promis
     return
   }
 
-  for (const sib of manifest.siblings) {
-    const abs = path.resolve(cwd, sib.path)
-    if (await exists(abs)) {
-      console.info(`linkRemote --from: ${sib.path} already present; leaving as-is`)
-      continue
-    }
-    if (!sib.sha) throw new Error(`Manifest entry "${sib.repo}" has no sha to pin`)
-    console.info(`linkRemote --from: pinning ${sib.repo}@${sib.sha} -> ${sib.path}`)
-    clonePinned(repoUrl(sib.repo), sib.sha, abs)
-  }
+  // Pinned clones are mutually independent (each at a recorded SHA, no discovery), so materialize
+  // them all in parallel; leaves-first install order is still enforced below.
+  await Promise.all(
+    manifest.siblings.map(async (sib) => {
+      const abs = path.resolve(cwd, sib.path)
+      if (await exists(abs)) {
+        console.info(`linkRemote --from: ${sib.path} already present; leaving as-is`)
+        return
+      }
+      if (!sib.sha) throw new Error(`Manifest entry "${sib.repo}" has no sha to pin`)
+      console.info(`linkRemote --from: pinning ${sib.repo}@${sib.sha} -> ${sib.path}`)
+      await clonePinned(repoUrl(sib.repo), sib.sha, abs)
+    }),
+  )
 
   installLeavesFirst(
     cwd,