@changfenhuang/dsh-genui 0.9.1

package/src/shared/fence-repair.ts

@@ -0,0 +1,244 @@
+/**
+ * Shared fence-body JSON repair — pure string functions, no DOM, no I/O.
+ * Used by BOTH the client fence renderer (tier-1/tier-2 auto-repair before
+ * rendering) and the node-side validate_dsh_ui tool (which returns the
+ * repaired JSON to the model instead of making it re-author the fix).
+ *
+ * Two tiers, deliberately gated differently by the callers:
+ * - Tier-1 (`repairFenceJson`): heals the most common model JSON typos that
+ *   do NOT change the body's structure — unescaped half-width quotes inside
+ *   string values and trailing commas. Safe at any time (streaming included),
+ *   adopted only when the WHOLE body parses afterwards.
+ * - Tier-2 (`completeFenceJson`): heals structural incompleteness — missing
+ *   closing quotes/brackets — by appending the missing terminators, and
+ *   skips mismatched closers (a `]` mistyped as `}`, duplicated terminators).
+ *   SETTLED MESSAGES ONLY: a streaming half must never be adopted as a
+ *   finished prefix.
+ * @module @changfenhuang/dsh-genui/shared/fence-repair
+ */
+
+/** A fence body counts as complete when it parses as a whole JSON value. */
+export function isCompleteJson(raw: string): boolean {
+  try {
+    JSON.parse(raw)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** Short human-readable reason for a body that fails whole-JSON parsing, or
+ * null when it parses. Positions come from the host's JSON.parse error. */
+export function describeJsonFailure(raw: string): string | null {
+  try {
+    JSON.parse(raw)
+    return null
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    const pos = msg.match(/position (\d+)/i)
+    const where = pos !== null ? `（字符 ${pos[1]} 附近）` : ''
+    return `${where}${msg.slice(0, 140)}`
+  }
+}
+
+/**
+ * Tier-1 repair — SAFE AT ANY TIME (streaming included): heals the most
+ * common model JSON typos that do NOT change the body's structure, and only
+ * when the whole body parses afterwards (so a still-growing streaming half
+ * can never be adopted):
+ *
+ * 1. Unescaped half-width `"` inside a string value — Chinese text quoted
+ *    with ASCII quotes (e.g. `对"别名路径"判定失败`), which makes JSON.parse
+ *    fail near that quote with "Expected ',' or ']'...".
+ * 2. Trailing commas before `}` / `]` or at end of input.
+ *
+ * The state-machine scan walks the raw body tracking string-open state:
+ * - inside a string, a quote whose next non-space char is NOT one of `, ] } :`
+ *   (or end of input) cannot legally close the string → escape it as `\"`;
+ * - a `,` whose next non-space char is `}` / `]` / end of input is a trailing
+ *   comma → drop it.
+ *
+ * Returns `{ text, repairs }` on success, or null when nothing needed fixing
+ * or the body still does not parse (callers fall through to tier-2 / banner).
+ */
+export function repairFenceJson(raw: string): { text: string; repairs: number } | null {
+  try {
+    JSON.parse(raw)
+    return null
+  } catch {
+    // fall through to the repair scan
+  }
+  let out = ''
+  let inString = false
+  let escaped = false
+  let repairs = 0
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i]
+    if (escaped) {
+      out += ch
+      escaped = false
+      continue
+    }
+    if (inString && ch === '\\') {
+      out += ch
+      escaped = true
+      continue
+    }
+    if (ch === '"') {
+      if (!inString) {
+        inString = true
+        out += ch
+        continue
+      }
+      // Inside a string: is this quote the terminator? Look past whitespace.
+      let j = i + 1
+      while (j < raw.length && (raw[j] === ' ' || raw[j] === '\t' || raw[j] === '\n' || raw[j] === '\r')) j++
+      const next = j < raw.length ? raw[j] : ''
+      if (next === ',' || next === ']' || next === '}' || next === ':' || next === '') {
+        inString = false
+        out += ch
+      } else {
+        // Free-standing quote inside a value → escape it.
+        out += '\\"'
+        repairs++
+      }
+      continue
+    }
+    if (ch === ',') {
+      // Trailing comma before `}` / `]` / end of input → drop it.
+      let j = i + 1
+      while (j < raw.length && (raw[j] === ' ' || raw[j] === '\t' || raw[j] === '\n' || raw[j] === '\r')) j++
+      const next = j < raw.length ? raw[j] : ''
+      if (next === '}' || next === ']' || next === '') {
+        repairs++
+        continue
+      }
+    }
+    out += ch
+  }
+  if (repairs === 0) return null
+  try {
+    JSON.parse(out)
+    return { text: out, repairs }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Tier-2 repair — SETTLED MESSAGES ONLY (never while streaming): heals
+ * structural incompleteness — missing closing quotes/brackets — by appending
+ * the missing terminators, and heals stray closers — a `]` mistyped as `}` or
+ * a duplicated terminator — by skipping closers that do not match the open
+ * stack (they cannot be legal JSON). Callers gate it on settled messages (the
+ * client uses the host-provided fence source; the validate tool is by
+ * definition pre-emission), so a streaming half can never flash premature UI.
+ *
+ * ONE unified scan: the tier-1 fixes (quote escaping + trailing-comma drops)
+ * are folded into the same pass, so bodies that combine BOTH defect classes
+ * (a trailing comma AND a missing closer) heal in one shot — the old
+ * two-phase chain lost tier-1's partial work when its whole-body parse
+ * failed, and re-scanning the raw text could not compose the repairs.
+ * Adopted only when the completed body parses as whole JSON.
+ */
+export function completeFenceJson(raw: string): { text: string; repairs: number } | null {
+  try {
+    JSON.parse(raw)
+    return null
+  } catch {
+    // fall through to the unified repair scan
+  }
+  let out = ''
+  const stack: Array<'}' | ']'> = []
+  let inString = false
+  let escaped = false
+  let repairs = 0
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i]
+    if (escaped) {
+      out += ch
+      escaped = false
+      continue
+    }
+    if (inString) {
+      if (ch === '\\') {
+        out += ch
+        escaped = true
+        continue
+      }
+      if (ch !== '"') {
+        out += ch
+        continue
+      }
+      // Inside a string: is this quote the terminator? Look past whitespace.
+      let j = i + 1
+      while (j < raw.length && (raw[j] === ' ' || raw[j] === '\t' || raw[j] === '\n' || raw[j] === '\r')) j++
+      const next = j < raw.length ? raw[j] : ''
+      if (next === ',' || next === ']' || next === '}' || next === ':' || next === '') {
+        inString = false
+        out += ch
+      } else {
+        // Free-standing quote inside a value → escape it (tier-1 fix).
+        out += '\\"'
+        repairs++
+      }
+      continue
+    }
+    if (ch === '"') {
+      inString = true
+      out += ch
+      continue
+    }
+    if (ch === '{') {
+      stack.push('}')
+      out += ch
+      continue
+    }
+    if (ch === '[') {
+      stack.push(']')
+      out += ch
+      continue
+    }
+    if (ch === '}' || ch === ']') {
+      if (stack[stack.length - 1] === ch) {
+        stack.pop()
+        out += ch
+      } else {
+        // Mismatched closer (e.g. a `]` mistyped as `}`, or a duplicated
+        // terminator): no legal JSON can contain it here, so skip it and let
+        // the remaining closers pair up again. The whole-body parse below is
+        // the final arbiter — if skipping made things worse, nothing is
+        // adopted and the diagnostic banner stays.
+        repairs++
+      }
+      continue
+    }
+    if (ch === ',') {
+      // Trailing comma before `}` / `]` / end of input → drop it (tier-1 fix).
+      let j = i + 1
+      while (j < raw.length && (raw[j] === ' ' || raw[j] === '\t' || raw[j] === '\n' || raw[j] === '\r')) j++
+      const next = j < raw.length ? raw[j] : ''
+      if (next === '}' || next === ']' || next === '') {
+        repairs++
+        continue
+      }
+    }
+    out += ch
+  }
+  if (inString) {
+    // Unterminated string value → close it.
+    out += '"'
+    repairs++
+  }
+  while (stack.length > 0) {
+    out += stack.pop()
+    repairs++
+  }
+  if (repairs === 0) return null
+  try {
+    JSON.parse(out)
+    return { text: out, repairs }
+  } catch {
+    return null
+  }
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    "target": "es2024",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "lib": [
+      "ES2024",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "types": [
+      "node"
+    ],
+    "declaration": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "rootDir": "src",
+    "outDir": "lib",
+    "emitDeclarationOnly": true,
+    "declarationDir": "lib/types"
+  },
+  "include": [
+    "src"
+  ]
+}

package/tsdown.config.ts

@@ -0,0 +1,193 @@
+/**
+ * dsh-genui build: node-half lib (host plugin, prompt injection) + browser
+ * client bundle (the dsh-ui renderer) speaking the dsh module-loader
+ * protocol (`window.__ModuleLoader__.load`). Mirrors the dsh repo's
+ * packages/client/tsdown.client.ts preset, simplified for one package.
+ *
+ * Deterministic output: the CSS Modules class map is emitted in fixed
+ * UTF-16 local-name order (never localeCompare — system-locale drift), and
+ * the production browser bundle carries no sourcemap, so the same source
+ * builds byte-identical client.js every time.
+ */
+import { readFile } from 'node:fs/promises'
+import { basename, dirname, relative, resolve as resolvePath } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { UserConfig } from 'tsdown'
+import { transform } from 'lightningcss'
+
+const ID = '@changfenhuang/dsh-genui'
+const PROJECT_ROOT = dirname(fileURLToPath(import.meta.url))
+
+/** Module-table entries this bundle may leave external: platform seed rows
+ * (react family, cordis, ui-primitives) answered by the loader's require.
+ * `react-dom/client` joins the list for the DOM render channel (pure-plugin
+ * fence rendering on pristine hosts mounts its own React roots). */
+const EXTERNALS = [
+  'react', 'react/jsx-runtime', 'react-dom/client', '@deepseek-ai/cordis', '@deepseek-ai/dsh-client-ui-primitives',
+]
+
+const CSS_VIRTUAL_PREFIX = '\0dsh-css:'
+const CSS_VIRTUAL_SUFFIX = '.mjs'
+
+
+function cssModulesPlugin(): NonNullable<UserConfig['plugins']>[number] {
+  return {
+    name: 'dsh-css-modules-inline',
+    resolveId(source: string, importer: string | undefined) {
+      if (!source.endsWith('.module.css')) return null
+      // The bundle builds straight from src, so the importer's directory is
+      // always the source tree — no lib/types backtracking needed.
+      const abs = importer !== undefined ? resolvePath(dirname(importer), source) : source
+      const stableId = relative(PROJECT_ROOT, abs).replaceAll('\\', '/')
+      return CSS_VIRTUAL_PREFIX + stableId + CSS_VIRTUAL_SUFFIX
+    },
+    async load(virtualId: string) {
+      if (!virtualId.startsWith(CSS_VIRTUAL_PREFIX)) return null
+      const stableId = virtualId.slice(CSS_VIRTUAL_PREFIX.length, -CSS_VIRTUAL_SUFFIX.length)
+      const fileId = resolvePath(PROJECT_ROOT, stableId)
+      this.addWatchFile(fileId)
+      const source = await readFile(fileId)
+      const { code, exports: cssExports } = transform({
+        filename: stableId,
+        code: source,
+        cssModules: { pattern: '[hash]_[local]' },
+        minify: true,
+      })
+      // Deterministic key order: fixed UTF-16 comparison on the LOCAL class
+      // names (localeCompare depends on the system locale). Values unchanged.
+      const entries = Object.entries(cssExports ?? {})
+        .map(([local, exp]) => [local, exp.name] as const)
+        .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+      const classMap = Object.fromEntries(entries)
+      const tagId = `${ID}/${basename(fileId)}`
+      return [
+        `const css = ${JSON.stringify(code.toString())};`,
+        `const tagId = ${JSON.stringify(tagId)};`,
+        `if (typeof document !== 'undefined' && document.querySelector('style[data-plugin-css=' + JSON.stringify(tagId) + ']') === null) {`,
+        `  const tag = document.createElement('style');`,
+        `  tag.dataset.plugin = ${JSON.stringify(ID)};`,
+        '  tag.dataset.pluginCss = tagId;',
+        '  tag.textContent = css;',
+        '  document.head.appendChild(tag);',
+        '}',
+        `export default ${JSON.stringify(classMap)};`,
+      ].join('\n')
+    },
+  }
+}
+
+function purityGate(): NonNullable<UserConfig['plugins']>[number] {
+  return {
+    name: 'dsh-client-bundle-purity',
+    resolveId(source: string) {
+      if (!source.startsWith('@deepseek-ai/')) return null
+      if (EXTERNALS.includes(source)) return null
+      throw new Error(
+        `client bundle purity: "${source}" is not in the module table (EXTERNALS) — `
+        + 'cross-plugin value imports are forbidden; collaborate through cordis services',
+      )
+    },
+  }
+}
+
+const clientConfig: UserConfig = {
+  name: `${ID}/client`,
+  entry: { client: 'src/client/index.tsx' },
+  outDir: 'lib',
+  format: 'cjs',
+  platform: 'browser',
+  dts: false,
+  // Minified production bundles: the host serves plugin bytes uncompressed,
+  // so every byte counts at first-load time.
+  minify: true,
+  // No sourcemap in the production bundle: nothing ships the map, nothing
+  // rewrites paths, builds are byte-identical.
+  sourcemap: false,
+  clean: false,
+  deps: {
+    neverBundle: [...EXTERNALS],
+    alwaysBundle: (id: string) => !EXTERNALS.includes(id),
+  },
+  define: {
+    'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV ?? 'production'),
+    'import.meta.env.MODE': JSON.stringify(process.env.NODE_ENV ?? 'production'),
+    'import.meta.env': JSON.stringify({ MODE: process.env.NODE_ENV ?? 'production' }),
+  },
+  plugins: [purityGate(), cssModulesPlugin()],
+  outputOptions: {
+    entryFileNames: 'client.js',
+    // The loader fetches one script per plugin; the lazy mermaid/three
+    // engines are NOT part of this bundle anymore — they ship as standalone
+    // IIFE assets under lib/assets/, fetched on demand by the runtime loaders
+    // (see asset-loader.ts). Nothing heavy may re-enter this bundle.
+    codeSplitting: false,
+    banner: `window.__ModuleLoader__.load({ id: ${JSON.stringify(ID)}, factory: (require) => {`,
+    footer: 'return module.exports; } });',
+    intro: 'var module = { exports: {} }; var exports = module.exports;',
+  },
+}
+
+/**
+ * Lazy engine assets: mermaid and three ship as standalone single-entry
+ * IIFEs that register themselves on `window.__GenuiAssets__` (no
+ * module-loader protocol — the loaders read the global directly after script
+ * injection). Two configs because rolldown refuses IIFE with multiple
+ * entries; each bundle is fully independent (no cross-entry chunks). The
+ * main client bundle never contains either engine, so the eager download
+ * drops from ~9 MB to the small renderer core.
+ */
+function assetConfig(name: 'mermaid' | 'three' | 'echarts', entry: string): UserConfig {
+  return {
+    name: `${ID}/assets/${name}`,
+    entry: { [`assets/${name}`]: entry },
+    outDir: 'lib',
+    format: 'iife',
+    platform: 'browser',
+    dts: false,
+    // Minified: these engines are huge unminified (6.7 MB / 1.8 MB) and the
+    // host serves uncompressed bytes; on-demand loads still want them small.
+    minify: true,
+    sourcemap: false,
+    clean: false,
+    deps: {
+      neverBundle: [...EXTERNALS],
+      alwaysBundle: (id: string) => !EXTERNALS.includes(id),
+    },
+    define: {
+      'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV ?? 'production'),
+    },
+    plugins: [purityGate()],
+    outputOptions: {
+      entryFileNames: '[name].js',
+    },
+  }
+}
+
+const libConfig: UserConfig = {
+  name: ID,
+  // Named entries keep the published layout stable (lib/index.js +
+  // lib/invariant.js) while src/index.ts becomes the canonical bundle
+  // source entry that plugin_check's tool-bundle contract expects.
+  entry: { index: 'src/index.ts', invariant: 'src/plugin/invariant.ts' },
+  outDir: 'lib',
+  format: ['esm'],
+  platform: 'node',
+  target: 'es2024',
+  fixedExtension: false,
+  dts: false,
+  // Flatten entry outputs to lib/<basename>.js so package exports keep the
+  // stable paths lib/index.js + lib/invariant.js (a directory-mirroring
+  // default would emit lib/plugin/invariant.js).
+  outputOptions: { entryFileNames: '[name].js' },
+  // Cleanup happens in the build script (`rm -rf lib` before tsc): tsdown
+  // must never wipe lib/types (tsc's declaration output) mid-pipeline.
+  clean: false,
+}
+
+export default [
+  libConfig,
+  clientConfig,
+  assetConfig('mermaid', 'src/client/asset-mermaid.ts'),
+  assetConfig('three', 'src/client/asset-three.ts'),
+  assetConfig('echarts', 'src/client/asset-echarts.ts'),
+]