chore: tighten TypeScript duplication lint

scripts/gen-module-graph.ts

@@ -18,23 +18,18 @@
  *                                                is stale (CI / pre-push gate)
  */
 
-import { dirname, resolve } from 'node:path'
-import { globSync, readFileSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { readFileSync, writeFileSync } from 'node:fs'
+import {
+  collectPackageGraph,
+  escapeMermaidLabel as escLabel,
+  graphNodeId as nodeId,
+  type PackageGraphNode,
+} from './package-graph.ts'
 
 const root = resolve(import.meta.dirname, '..')
 const OUT = 'docs/module-graph.md'
-const SCOPE = '@deepseek-ai/dsh-'
-
-interface Pkg {
-  /** Short name, `@deepseek-ai/dsh-` prefix stripped (e.g. `agent-loop`). */
-  short: string
-  /** Package group from `packages/<group>/<pkg>`. */
-  group: string
-  /** Repo-relative package directory. */
-  rel: string
-  /** Short names of this package's in-repo peer dependencies, sorted. */
-  deps: string[]
-}
+type Pkg = PackageGraphNode
 
 const GROUP_ORDER = [
   'util',
@@ -55,67 +50,6 @@ const GROUP_ORDER = [
   'ui',
 ]
 
-/** Read every workspace package and its `@deepseek-ai/dsh-*` peer edges. */
-function collect(): Pkg[] {
-  const pkgs: Pkg[] = []
-  for (const rel of globSync('packages/*/*/package.json', { cwd: root })) {
-    const json = JSON.parse(readFileSync(resolve(root, rel), 'utf8')) as {
-      name: string
-      peerDependencies?: Record<string, string>
-    }
-    if (!json.name.startsWith(SCOPE)) continue
-    const deps = Object.keys(json.peerDependencies ?? {})
-      .filter(d => d.startsWith(SCOPE))
-      .map(d => d.slice(SCOPE.length))
-      .sort()
-    const [, group, leaf] = rel.split('/')
-    if (group === undefined || leaf === undefined) throw new Error(`gen-module-graph: unexpected package path ${rel}`)
-    pkgs.push({ short: json.name.slice(SCOPE.length), group, rel: dirname(rel), deps })
-  }
-  return topoSort(pkgs)
-}
-
-/**
- * Order packages low-level → high-level: a package appears only after every
- * package it depends on. Kahn-style layering with an alphabetical tiebreak
- * within each layer, so the output stays deterministic (the freshness check
- * compares whole-file). The graph is a DAG, so this always terminates; a cycle
- * would leave nodes unplaced and throw.
- */
-function topoSort(pkgs: Pkg[]): Pkg[] {
-  const remaining = new Map(pkgs.map(p => [p.short, p]))
-  const placed = new Set<string>()
-  const out: Pkg[] = []
-  while (remaining.size > 0) {
-    const ready = [...remaining.values()]
-      .filter(p => p.deps.every(d => placed.has(d)))
-      .sort(comparePackages)
-    if (ready.length === 0) throw new Error(`gen-module-graph: dependency cycle among ${[...remaining.keys()].join(', ')}`)
-    for (const p of ready) {
-      out.push(p)
-      placed.add(p.short)
-      remaining.delete(p.short)
-    }
-  }
-  return out
-}
-
-function comparePackages(a: Pkg, b: Pkg): number {
-  const groupA = GROUP_ORDER.indexOf(a.group)
-  const groupB = GROUP_ORDER.indexOf(b.group)
-  const normA = groupA === -1 ? Number.MAX_SAFE_INTEGER : groupA
-  const normB = groupB === -1 ? Number.MAX_SAFE_INTEGER : groupB
-  return normA - normB || a.group.localeCompare(b.group) || a.short.localeCompare(b.short)
-}
-
-function nodeId(prefix: string, value: string): string {
-  return `${prefix}_${value.replace(/[^a-zA-Z0-9_]/g, '_')}`
-}
-
-function escLabel(value: string): string {
-  return value.replace(/"/g, '\\"')
-}
-
 function packageLink(pkg: Pkg): string {
   return `[\`${pkg.short}\`](../${pkg.rel})`
 }
@@ -170,7 +104,7 @@ function render(pkgs: Pkg[]): string {
   ].join('\n')
 }
 
-const content = render(collect())
+const content = render(collectPackageGraph(root, GROUP_ORDER, 'gen-module-graph'))
 
 if (process.argv.includes('--check')) {
   let committed: string | null = null