@chatcode/cco-market 1.45.1

package/src/order.ts

@@ -0,0 +1,303 @@
+/**
+ * Community bundle ordering — issue #98 (phase 2): let the user reorder the
+ * community bundles of the profile's layer stack, with author-declared
+ * before/after rules enforced before anything is written.
+ *
+ * Official in-box bundles (@deepseek-ai/dsh-base, @deepseek-ai/dsh-web-app,
+ * @deepseek-ai/dsh-headless) are fixed: they keep their exact positions in
+ * the stack, are never part of a user-supplied order, and are never added,
+ * removed or duplicated by a reorder (#98 boundary). The profile's own
+ * cordis.patch.yml and --patch overlays are not part of the bundle stack and
+ * are never touched here.
+ *
+ * Pure functions plus one manifest write-back; no processes, no network.
+ */
+
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { findDshInstallDir } from './dsh-install.ts'
+
+/** Profile bundles that ship with the dsh host and must stay put (#98). */
+export const INBOX_BUNDLES = new Set([
+  '@deepseek-ai/dsh-base',
+  '@deepseek-ai/dsh-web-app',
+  '@deepseek-ai/dsh-headless',
+])
+
+/**
+ * Atomic same-directory replace (write temp + rename): a crash mid-write can
+ * never leave the profile manifest truncated, which would break every later
+ * pnpm run. Used for every package.json write this module makes.
+ */
+function writeFileAtomic(file: string, content: string): void {
+  const temp = `${file}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  writeFileSync(temp, content)
+  renameSync(temp, file)
+}
+
+/** The bundle stack as it appears in the profile manifest. */
+export interface BundleStack {
+  /** Full ordered list from dsh.profile.bundles. */
+  bundles: string[]
+  /** The subset that may be reordered (community bundles). */
+  community: string[]
+}
+
+/** Author-declared ordering constraints of one bundle. */
+export interface BundleRule {
+  name: string
+  /** This bundle must load after every name in this list. */
+  after: string[]
+  /** This bundle must load before every name in this list. */
+  before: string[]
+}
+
+/** A violated before/after rule in the current or proposed order. */
+export interface OrderConflict {
+  name: string
+  reason: string
+}
+
+/** Read the profile's bundle stack (empty when the manifest is unreadable). */
+export function readBundleStack(profileDir: string): BundleStack {
+  try {
+    const manifest = JSON.parse(readFileSync(join(profileDir, 'package.json'), 'utf8')) as {
+      dsh?: { profile?: { bundles?: unknown } }
+    }
+    const bundles = Array.isArray(manifest.dsh?.profile?.bundles)
+      ? manifest.dsh.profile.bundles.filter((name): name is string => typeof name === 'string')
+      : []
+    return {
+      bundles,
+      community: bundles.filter(name => !INBOX_BUNDLES.has(name)),
+    }
+  } catch {
+    return { bundles: [], community: [] }
+  }
+}
+
+/**
+ * The bundle package.json, resolved the way the dsh boot resolves bundles
+ * (dsh-app-boot's resolveBundleDir, mirrored by check.ts): the dsh
+ * installation anchor first — official in-box bundles live in the install's
+ * node_modules, never the profile's — then the profile directory, whose
+ * createRequire search paths also cover pnpm workspace-root hoisting
+ * (`<profiles>/node_modules` when the profile lives under `<profiles>/<name>`).
+ */
+function resolveBundlePackageJson(profileDir: string, name: string): string | null {
+  const dshInstall = findDshInstallDir()
+  const anchors = [
+    dshInstall !== null ? join(dshInstall, 'package.json') : null,
+    join(profileDir, 'package.json'),
+  ]
+  for (const anchor of anchors) {
+    if (anchor === null) continue
+    let paths: string[] = []
+    try {
+      paths = createRequire(anchor).resolve.paths(name) ?? []
+    } catch {
+      continue
+    }
+    for (const searchPath of paths) {
+      const candidate = join(searchPath, name)
+      if (existsSync(join(candidate, 'package.json'))) return join(candidate, 'package.json')
+    }
+  }
+  return null
+}
+
+/**
+ * Read each bundle's declared ordering rules from its package manifest
+ * (`dsh.bundle.order.{before,after}` — a list of bundle package names).
+ * Unresolvable packages and missing declarations contribute nothing.
+ */
+export function readBundleRules(profileDir: string): BundleRule[] {
+  const { bundles } = readBundleStack(profileDir)
+  const rules: BundleRule[] = []
+  for (const name of bundles) {
+    const packageJson = resolveBundlePackageJson(profileDir, name)
+    if (packageJson === null) continue
+    try {
+      const manifest = JSON.parse(
+        readFileSync(packageJson, 'utf8'),
+      ) as { dsh?: { bundle?: { order?: unknown } } }
+      const order = manifest.dsh?.bundle?.order
+      if (order === null || typeof order !== 'object' || Array.isArray(order)) continue
+      const listOf = (value: unknown): string[] => Array.isArray(value)
+        ? value.filter((item): item is string => typeof item === 'string')
+        : []
+      const rule: BundleRule = {
+        name,
+        after: listOf((order as Record<string, unknown>).after),
+        before: listOf((order as Record<string, unknown>).before),
+      }
+      if (rule.after.length > 0 || rule.before.length > 0) rules.push(rule)
+    } catch { /* package unreadable — no rule */ }
+  }
+  return rules
+}
+
+/**
+ * Check a bundle order against the declared before/after rules. Rules naming
+ * bundles outside `order` are ignored (a rule for a not-yet-installed bundle
+ * must not block the current stack).
+ * @returns every violated rule with a readable reason; [] when all hold.
+ */
+export function validateOrder(bundleNames: string[], rules: BundleRule[]): OrderConflict[] {
+  const position = new Map(bundleNames.map((name, index) => [name, index]))
+  const conflicts: OrderConflict[] = []
+  for (const rule of rules) {
+    const pos = position.get(rule.name)
+    if (pos === undefined) continue
+    for (const other of rule.after) {
+      const otherPos = position.get(other)
+      if (otherPos === undefined) continue
+      if (otherPos >= pos) {
+        conflicts.push({
+          name: rule.name,
+          reason: `must load after ${other}, but ${other} is currently before/equal (position ${otherPos} vs ${pos})`,
+        })
+      }
+    }
+    for (const other of rule.before) {
+      const otherPos = position.get(other)
+      if (otherPos === undefined) continue
+      if (otherPos <= pos) {
+        conflicts.push({
+          name: rule.name,
+          reason: `must load before ${other}, but ${other} is currently after/equal (position ${otherPos} vs ${pos})`,
+        })
+      }
+    }
+  }
+  return conflicts
+}
+
+/**
+ * Merge a community-bundle permutation into the full stack. Official in-box
+ * bundles keep their EXACT positions (never moved); community bundles are
+ * replaced by `newOrder` in order of appearance. Pure — nothing is written.
+ * @returns the merged full stack, or the rejection reason when `newOrder` is
+ * not a permutation of the community bundles (duplicates, additions,
+ * omissions, official names).
+ */
+export function mergeOrder(bundles: string[], newOrder: string[]): { ok: true; bundles: string[] } | { ok: false; error: string } {
+  const communitySet = new Set(bundles.filter(name => !INBOX_BUNDLES.has(name)))
+  if (new Set(newOrder).size !== newOrder.length) {
+    return { ok: false, error: 'duplicate bundle names in the new order / 新顺序包含重复的 bundle' }
+  }
+  if (newOrder.length !== communitySet.size) {
+    return { ok: false, error: 'the new order must contain exactly the current community bundles / 新顺序必须恰好包含全部社区 bundle' }
+  }
+  for (const name of newOrder) {
+    if (!communitySet.has(name)) {
+      return { ok: false, error: `${name} is not a reorderable community bundle / ${name} 不是可排序的社区 bundle` }
+    }
+  }
+  const merged = [...bundles]
+  let cursor = 0
+  for (let index = 0; index < merged.length; index += 1) {
+    const name = merged[index]
+    if (name === undefined || INBOX_BUNDLES.has(name)) continue
+    merged[index] = newOrder[cursor]
+    cursor += 1
+  }
+  return { ok: true, bundles: merged }
+}
+
+/**
+ * Topologically sort the community bundles by their before/after rules — the
+ * "auto-fix" counterpart to validateOrder. Returns null when no declared rule
+ * applies to the current stack (nothing to suggest). With rules, Kahn's
+ * algorithm breaks ties by the CURRENT order: unconstrained bundles keep
+ * their current relative order and constrained bundles move only as far as
+ * the rules require — the suggestion is the minimal change that satisfies
+ * every rule, never an arbitrary canonical rewrite of a hand-picked order
+ * (issue #125 review).
+ * @returns the suggested community order, null when there are no rules, or a
+ * cycle report when the constraints cannot be satisfied (references to
+ * unlisted bundles ignored).
+ */
+export function suggestOrder(
+  bundleNames: string[],
+  rules: BundleRule[],
+): { ok: true; order: string[] } | { ok: false; cycle: string[] } | null {
+  const names = bundleNames.filter(name => !INBOX_BUNDLES.has(name))
+  const inOrder = new Set(names)
+  const active = rules.filter(rule => inOrder.has(rule.name))
+  // No rule applies to the current stack — nothing to suggest.
+  if (active.length === 0) return null
+  const position = new Map(names.map((name, index) => [name, index]))
+  // Constraint: "a must load before b" (from a.before or b.after) → edge a → b.
+  const beforeOf = new Map<string, Set<string>>() // name → bundles that must come after it
+  const deps = new Map<string, Set<string>>() // name → bundles that must come before it
+  for (const name of names) {
+    beforeOf.set(name, new Set())
+    deps.set(name, new Set())
+  }
+  const addEdge = (a: string, b: string): void => {
+    if (!inOrder.has(a) || !inOrder.has(b) || a === b) return
+    beforeOf.get(a)?.add(b)
+    deps.get(b)?.add(a)
+  }
+  for (const rule of active) {
+    for (const other of rule.before) addEdge(rule.name, other)
+    for (const other of rule.after) addEdge(other, rule.name)
+  }
+  const remaining = new Map<string, Set<string>>()
+  for (const [name, depsOf] of deps) remaining.set(name, new Set(depsOf))
+  const ready: string[] = names.filter(name => (remaining.get(name)?.size ?? 0) === 0)
+  const ordered: string[] = []
+  while (ready.length > 0) {
+    // Minimal-change tie-break: among the ready bundles, prefer the one that
+    // comes FIRST in the current order. Bundles the rules do not constrain
+    // therefore keep their current relative order; constrained bundles move
+    // only as far as the rules require (issue #125 review).
+    let best = 0
+    for (let i = 1; i < ready.length; i += 1) {
+      const a = ready[i]
+      const b = ready[best]
+      if (a !== undefined && b !== undefined && (position.get(a) ?? 0) < (position.get(b) ?? 0)) best = i
+    }
+    const name = ready.splice(best, 1)[0]
+    if (name === undefined) break
+    ordered.push(name)
+    for (const dependent of beforeOf.get(name) ?? []) {
+      const depsOf = remaining.get(dependent)
+      if (depsOf === undefined) continue
+      depsOf.delete(name)
+      if (depsOf.size === 0 && !ordered.includes(dependent) && !ready.includes(dependent)) ready.push(dependent)
+    }
+  }
+  if (ordered.length < names.length) {
+    return { ok: false, cycle: names.filter(name => !ordered.includes(name)) }
+  }
+  return { ok: true, order: ordered }
+}
+
+/**
+ * Apply a new community-bundle order to the profile manifest. The official
+ * in-box bundles keep their exact positions; `newOrder` must be a permutation
+ * of the current community bundles (no duplicates, no additions, no
+ * omissions). On any failure the manifest is left untouched.
+ * @returns the new full stack on success, or an error description.
+ */
+export function applyBundleOrder(profileDir: string, newOrder: string[]): { ok: true; bundles: string[] } | { ok: false; error: string } {
+  const { bundles } = readBundleStack(profileDir)
+  const merged = mergeOrder(bundles, newOrder)
+  if (!merged.ok) return merged
+  try {
+    const manifestPath = join(profileDir, 'package.json')
+    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as {
+      dsh?: { profile?: { bundles?: unknown } }
+    }
+    manifest.dsh ??= {}
+    manifest.dsh.profile ??= {}
+    manifest.dsh.profile.bundles = merged.bundles
+    writeFileAtomic(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+    return merged
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) }
+  }
+}