@huaqiu/dsh-tool-schematic-gen 0.1.1

package/src/client/i18n.ts

@@ -0,0 +1,148 @@
+/**
+ * Runtime locale pack for the schematic/system HIT card (zh + en), default zh.
+ */
+import { useCallback } from 'react'
+import { useLocale } from './theme.js'
+
+/**
+ * Chinese is the source of truth: `CopyKey` is derived from it and `EN` is
+ * typed against it, so a key added to `ZH` but missing from `EN` is a COMPILE
+ * error instead of a silent Chinese fallback at runtime.
+ */
+const ZH = {
+    'card.title.schematic': '生成原理图',
+    'card.title.system': '生成系统设计',
+    'card.kind.schematic': '原理图',
+    'card.kind.system': '系统设计',
+    'card.status.generating': '正在生成…',
+    'card.status.generated': '已生成',
+    'card.status.failed': '生成失败',
+    // Live progress: one label per rung of the coarse stage ladder. The keys
+    // match `STAGE_LADDERS` in src/progress.ts; a run can take 10+ minutes, so
+    // these are what the user reads while waiting.
+    'card.progress.waiting': '正在等待智能体开始…',
+    'card.stage.requirement': '解析需求',
+    'card.stage.architecture': '设计架构',
+    'card.stage.circuit': '设计电路',
+    'card.stage.report': '撰写报告',
+    'card.stage.output': '导出图纸',
+    'card.stage.plan': '制定方案',
+    'card.stage.search': '检索器件',
+    'card.stage.bom': '生成 BOM',
+    'card.stage.modules': '设计模块',
+    'card.stage.connect': '连接网络',
+    'card.stage.erc': 'ERC 检查',
+    'card.stage.export': '导出工程',
+    'card.preview.loading': '正在加载预览…',
+    'card.preview.renderError': '预览渲染失败：',
+    'card.preview.resolveError': '无法解析工件：',
+    'card.preview.missing': '没有可用于预览的工件内容',
+    'card.error.toolFailed': '工具调用失败',
+    'card.error.retry': '重试',
+    'card.meta.design': '设计',
+    'card.meta.sheets': '{count} 张图纸',
+    'card.meta.modules': '{count} 个模块',
+    'card.meta.connections': '{count} 条连接',
+    'card.action.download': '下载',
+    'card.action.downloading': '下载中…',
+    'card.action.regenerate': '重新生成',
+    'card.action.regenerating': '重新生成中…',
+    'card.action.inspect': '详情',
+    'card.regeneratePrompt.schematic': '请重新生成刚才的原理图',
+    'card.regeneratePrompt.system': '请重新生成刚才的系统设计',
+    'card.auth.title': '华秋 EDA AI（eda.cn）登录',
+    'card.auth.desc': '工具「{tool}」需要登录华秋 EDA AI 账号才能继续。请在下方的登录框完成登录（或点击左侧「华秋EDA AI登录」按钮）；登录完成后，回复助手「已登录，请重试」，助手会自动重新调用该工具。',
+    'card.auth.loggedIn': '✓ 已登录{nickname}—— 现在可以回复助手「已登录，请重试」，助手会重新调用工具。',
+    'card.auth.loggedOut': '未登录 —— 请在上方登录华秋 EDA AI（eda.cn）账号，或点击左侧「华秋EDA AI 登录」按钮；登录完成后让助手重试。',
+    // Substituted into `{nickname}` by `card.auth.loggedIn`. zh uses a
+    // full-width colon, en a half-width one plus a space — hardcoding '：'
+    // made the English card read "Logged in：John".
+    'card.nicknameSep': '：{nickname}',
+  } as const
+
+export type CopyKey = keyof typeof ZH
+
+const EN: Record<CopyKey, string> = {
+    'card.title.schematic': 'Generated schematic',
+    'card.title.system': 'Generated system design',
+    'card.kind.schematic': 'schematic',
+    'card.kind.system': 'system design',
+    'card.status.generating': 'Generating…',
+    'card.status.generated': 'Generated',
+    'card.status.failed': 'Failed',
+    'card.progress.waiting': 'Waiting for the agent to start…',
+    'card.stage.requirement': 'Parsing requirement',
+    'card.stage.architecture': 'Designing architecture',
+    'card.stage.circuit': 'Designing circuit',
+    'card.stage.report': 'Writing report',
+    'card.stage.output': 'Exporting sheets',
+    'card.stage.plan': 'Planning',
+    'card.stage.search': 'Searching parts',
+    'card.stage.bom': 'Building BOM',
+    'card.stage.modules': 'Designing modules',
+    'card.stage.connect': 'Connecting nets',
+    'card.stage.erc': 'Running ERC',
+    'card.stage.export': 'Exporting project',
+    'card.preview.loading': 'Loading preview…',
+    'card.preview.renderError': 'Preview render failed: ',
+    'card.preview.resolveError': 'Could not resolve artifact: ',
+    'card.preview.missing': 'No previewable artifact content',
+    'card.error.toolFailed': 'Tool call failed',
+    'card.error.retry': 'Retry',
+    'card.meta.design': 'Design',
+    'card.meta.sheets': '{count} sheet(s)',
+    'card.meta.modules': '{count} module(s)',
+    'card.meta.connections': '{count} connection(s)',
+    'card.action.download': 'Download',
+    'card.action.downloading': 'Downloading…',
+    'card.action.regenerate': 'Regenerate',
+    'card.action.regenerating': 'Regenerating…',
+    'card.action.inspect': 'Inspect',
+    'card.regeneratePrompt.schematic': 'Please regenerate the schematic above',
+    'card.regeneratePrompt.system': 'Please regenerate the system design above',
+    'card.auth.title': 'Huaqiu EDA AI (eda.cn) login',
+    // The reply phrase was hardcoded to the Chinese "已登录，请重试" even in
+    // this English string, telling an English-speaking user to type Chinese.
+    'card.auth.desc': 'Tool "{tool}" requires a Huaqiu EDA AI login. Complete the login below (or use the 华秋EDA AI sidebar button); then reply "I have logged in, please retry" so the assistant can retry the tool.',
+    'card.auth.loggedIn': '✓ Logged in{nickname} — reply "I have logged in, please retry" and the assistant will retry.',
+    'card.auth.loggedOut': 'Not logged in — complete the login above, or use the 华秋EDA AI sidebar button.',
+    'card.nicknameSep': ': {nickname}',
+}
+
+const COPY: Record<'zh' | 'en', Record<CopyKey, string>> = { zh: ZH, en: EN }
+
+/** Every copy key, in declaration order (used to assert bilingual balance). */
+export const COPY_KEYS = Object.keys(ZH) as CopyKey[]
+
+export type Translate = (key: string, params?: Record<string, unknown>) => string
+
+export function translate(lang: 'zh' | 'en', key: string, params?: Record<string, unknown>): string {
+  const dict = lang === 'en' ? COPY.en : COPY.zh
+  let v = dict[key as CopyKey]
+  if (v === undefined) v = COPY.zh[key as CopyKey]
+  if (v === undefined) v = key
+  if (params) {
+    for (const k of Object.keys(params)) {
+      v = v.split(`{${k}}`).join(String(params[k]))
+    }
+  }
+  return v
+}
+
+export const defaultT: Translate = (key, params) => translate('zh', key, params)
+
+/**
+ * Translate bound to the HOST UI language.
+ *
+ * The card used to hard-pin `const t = defaultT`, which silently froze every
+ * string to zh and left the `en` dictionary above as dead code. `useT()`
+ * follows the locale store in `theme.js` instead, so the card switches
+ * language with the app.
+ */
+export function useT(): Translate {
+  const lang = useLocale()
+  return useCallback(
+    (key: string, params?: Record<string, unknown>) => translate(lang, key, params),
+    [lang],
+  )
+}

package/src/client/index.ts

@@ -0,0 +1,176 @@
+/**
+ * `@huaqiu/dsh-tool-schematic-gen` — browser half (the schematic/system HIT).
+ *
+ * Registers keyed `tool.call.toolview` entries for both
+ * `generate_schematic_from_description` and `generate_system_module_graph`,
+ * replacing the stock JSON fallback (and the auth plugin's generic row) with
+ * the `GenHit` card: header → summary → ECAD canvas preview (single sheet for
+ * the schematic tool, project zip root sheet for the system tool) → actions.
+ *
+ * The authoritative state comes from DSH itself: the frozen `ToolCallBlock` is
+ * projected by the pure `projectToolCall()` into a single phase. Human answers
+ * ("regenerate") are sent back to the agent through
+ * `sessions.binding(sessionId).session.prompt`, so the node `ask()` stays the
+ * single source of truth.
+ */
+import { createElement, useEffect, useState, type ComponentType } from 'react'
+import { GenHit } from './hit-card.jsx'
+import { injectStyles, removeStyles, disposeThemeObserver } from './theme.js'
+import type { AuthStateLike, PromptSender } from './hit-card.jsx'
+
+export type { AuthStateLike, PromptSender }
+
+const TOOLVIEW_KEYS = [
+  'generate_schematic_from_description',
+  'generate_system_module_graph',
+] as const
+
+/**
+ * Client cordis inject: REAL service names only.
+ *
+ * `huaqiuAuth` is the client service provided by `@huaqiu/dsh-auth`. It is the
+ * ONLY sanctioned source of login state — this plugin must not read the
+ * credential cache itself (spec §10). Reading `localStorage` directly would
+ * duplicate the storage key and the expiry rule, and would report the user as
+ * permanently logged out whenever `@huaqiu/dsh-auth` runs in HQ Edge host mode
+ * (where there is no browser-side credential cache at all).
+ */
+export const inject: string[] = ['slots', 'sessions', 'huaqiuAuth']
+
+/** Minimal structural client context (dsh-client-runtime provides these). */
+export interface ClientContext {
+  provide?(name: string, value: unknown): () => void
+  slots?: {
+    inject(key: string, callback: () => () => void): () => void
+    register(spec: { name: string; key?: string; id?: string }, component: unknown): unknown
+  }
+  get<T = unknown>(name: string): T | undefined
+  effect?(fn: () => (() => void) | void, label?: string): void
+}
+
+/**
+ * Structural view of the `huaqiuAuth` CLIENT service (`@huaqiu/dsh-auth`).
+ *
+ * Declared structurally, never imported: each package must remain
+ * independently installable. `nickname` is optional because the HQ Edge host
+ * contract may not supply one.
+ */
+export interface HuaqiuAuthClientService {
+  auth?: {
+    isAuthenticated(): boolean
+    getUserInfo(): Promise<{ nickname?: string } | null>
+    onAuthStateChanged(listener: (info: { nickname?: string } | null) => void): () => void
+  }
+}
+
+const LOGGED_OUT: AuthStateLike = { authenticated: false }
+
+function stateOf(info: { nickname?: string } | null): AuthStateLike {
+  if (!info) return LOGGED_OUT
+  return {
+    authenticated: true,
+    ...(info.nickname ? { nickname: info.nickname } : {}),
+  }
+}
+
+/**
+ * Subscribe to the `huaqiuAuth` client service.
+ *
+ * Built as a hook rather than a plain read because the service resolves
+ * credentials asynchronously (`getUserInfo()`), while the card renders
+ * synchronously. The first paint uses the cheap synchronous
+ * `isAuthenticated()` so the card never flashes "logged out"; the effect then
+ * resolves the full payload once and follows every subsequent change.
+ */
+function createUseAuthState(auth: HuaqiuAuthClientService['auth'] | undefined): () => AuthStateLike {
+  return function useAuthState(): AuthStateLike {
+    const [state, setState] = useState<AuthStateLike>(() => ({
+      authenticated: auth?.isAuthenticated() ?? false,
+    }))
+
+    useEffect(() => {
+      if (!auth) {
+        setState(LOGGED_OUT)
+        return
+      }
+      let alive = true
+      void auth.getUserInfo()
+        .then((info) => { if (alive) setState(stateOf(info)) })
+        .catch(() => { if (alive) setState(LOGGED_OUT) })
+      const off = auth.onAuthStateChanged((info) => {
+        if (alive) setState(stateOf(info))
+      })
+      return () => {
+        alive = false
+        off()
+      }
+    }, [])
+
+    return state
+  }
+}
+
+export function apply(ctx: ClientContext): () => void {
+  const disposers: Array<() => void> = []
+
+  const authService = ctx.get<HuaqiuAuthClientService | undefined>('huaqiuAuth')
+  const useAuthState = createUseAuthState(authService?.auth)
+
+  const sendPrompt: PromptSender = (sessionId, message) => {
+    const sessions = ctx.get<{ binding(id: string): { session: { prompt(content: Array<{ type: 'text'; text: string }>, mode: 'queue'): Promise<unknown> } } | undefined }>('sessions')
+    if (!sessions || typeof sessions.binding !== 'function' || !sessionId) {
+      return Promise.reject(new Error('no session conversation channel'))
+    }
+    const binding = sessions.binding(sessionId)
+    const session = binding?.session
+    if (!session || typeof session.prompt !== 'function') {
+      return Promise.reject(new Error('no session conversation channel'))
+    }
+    return session.prompt([{ type: 'text', text: message }], 'queue')
+  }
+
+  const slots = ctx.slots
+  if (slots && typeof slots.inject === 'function' && typeof slots.register === 'function') {
+    const GenHitView: ComponentType<{
+      toolName?: string
+      block?: unknown
+      sessionId?: string
+      /**
+       * Published as part of `ToolCallOwnerProps` and stable across the
+       * running and settled forms. Forwarded so the card can correlate with
+       * the node half's progress store.
+       */
+      callId?: string
+      inspect?: () => void
+    }> = (props) =>
+      createElement(GenHit, {
+        ...props,
+        toolName: props.toolName ?? '',
+        block: props.block as never,
+        sessionId: props.sessionId,
+        callId: props.callId,
+        sendPrompt,
+        authState: useAuthState(),
+      })
+
+    for (const toolName of TOOLVIEW_KEYS) {
+      disposers.push(slots.inject('tool.call.toolview', () => slots.register(
+        { name: 'tool.call.toolview', key: toolName },
+        GenHitView,
+      ) as () => void))
+    }
+  }
+
+  injectStyles()
+
+  const cleanup = (): void => {
+    for (const dispose of disposers) {
+      try { dispose() } catch { /* already disposed */ }
+    }
+    disposers.length = 0
+    removeStyles()
+    disposeThemeObserver()
+  }
+  if (ctx.effect) ctx.effect(() => cleanup, 'schematic-gen: HIT dispose')
+  return cleanup
+}

package/src/client/login-url.ts

@@ -0,0 +1,91 @@
+/**
+ * auth.eda.cn embed URL contract for the `needs_auth` login card.
+ *
+ * SELF-CONTAINED ON PURPOSE: this package must stay independently
+ * installable, so it duplicates the ~40 lines of URL contract from
+ * `@huaqiu/dsh-auth` (`src/client/lib.ts`) instead of importing them. Keep
+ * the two in sync — `AUTH_IFRAME_VERSION` in particular is a shared
+ * cache-buster with the web app (`hq-eda-ai` LoginDialog).
+ *
+ * The embed has two rendering modes and this card uses FILL mode:
+ *
+ * - **Fill mode** (`fill=full`) — the embed's `DialogContent` becomes
+ *   `w-full h-full max-w-none max-h-none left-0 top-0 rounded-none border-none`
+ *   (`eda-cn-login/components/LoginDialog.tsx`, `fillFull` branch) and the
+ *   page wrapper drops `bg-transparent`, so the embed paints its own
+ *   `bg-background` edge-to-edge. That is what this card wants: the iframe
+ *   IS the surface, and fill mode is what removes the white gaps above and
+ *   below the form that the transparent mode's `grid-rows-[20px_1fr_20px]`
+ *   strips would otherwise leave showing the host surface.
+ * - **Transparent card mode** (no `fill`) — used by the sidebar-triggered
+ *   login dialog in `dsh-auth`, which paints its own host-colored card
+ *   around the iframe. Not used here.
+ */
+
+export const AUTH_ORIGIN = 'https://auth.eda.cn'
+
+/**
+ * Contract version of the auth.eda.cn embed, shared with the web app
+ * (`hq-eda-ai` LoginDialog) and `dsh-auth` so all three send the same
+ * cache-busting `v=`.
+ */
+export const AUTH_IFRAME_VERSION = '20260409'
+
+/**
+ * Iframe height. Sized so the embed's two-column layout (WeChat QR + phone
+ * form, which needs an iframe viewport ≥768px — Tailwind's `md` breakpoint)
+ * plus the agreement checkbox fits without an internal scrollbar.
+ */
+export const LOGIN_IFRAME_HEIGHT = 440
+
+/** UI language of the auth.eda.cn embed. */
+export type AuthLocale = 'zh' | 'en'
+
+/** Color scheme of the auth.eda.cn embed (its own vocabulary). */
+export type AuthTheme = 'light' | 'dark'
+
+/**
+ * auth.eda.cn's own language ids, keyed by our locale id. The embed's
+ * `LanguageContext.getLangFromUrl` only accepts these two ids from
+ * `locales/index.ts`; anything else silently falls back to the browser
+ * language. `lang=zh` (what hq-eda-ai sends) is ignored for the same reason,
+ * but we send it too for parity and forward compatibility.
+ */
+export const AUTH_LOCALE_ID: Record<AuthLocale, string> = { zh: 'cn', en: 'en' }
+
+export interface LoginUrlOptions {
+  /** Embed UI language (default `zh`). */
+  lang?: AuthLocale
+  /** Embed color scheme (default `light`). */
+  theme?: AuthTheme
+}
+
+/**
+ * Build the auth.eda.cn embed URL for this card: FILL mode, closing on an
+ * outside click, in the host's language and color scheme.
+ */
+export function buildLoginUrl(options: LoginUrlOptions = {}): string {
+  const url = new URL(`${AUTH_ORIGIN}/`)
+  url.searchParams.set('v', AUTH_IFRAME_VERSION)
+  url.searchParams.set('clickOutsideToClose', 'true')
+  // Fill mode: the card IS the surface, so let the embed paint it.
+  url.searchParams.set('fill', 'full')
+  const lang = options.lang ?? 'zh'
+  url.searchParams.set('locale', AUTH_LOCALE_ID[lang])
+  url.searchParams.set('lang', lang)
+  url.searchParams.set('theme', options.theme ?? 'light')
+  return url.toString()
+}
+
+/**
+ * Background for the iframe ELEMENT, matching the host surface.
+ *
+ * Even in fill mode the element needs a surface color: Blink's
+ * `BaseBackgroundColor()` falls back to WHITE until the embed's own CSS
+ * applies, which flashes a white block in dark mode on every card mount.
+ * The DSH alias token is preferred so custom host themes are honored, with a
+ * per-scheme fallback.
+ */
+export function loginIframeBackground(dark: boolean): string {
+  return dark ? 'var(--dsw-alias-bg-layer-1, #20242c)' : 'var(--dsw-alias-bg-layer-1, #ffffff)'
+}

package/src/client/parse.ts

@@ -0,0 +1,153 @@
+/**
+ * Pure projection layer for the schematic/system-design HIT card.
+ *
+ * Result shapes produced by the node half (`src/tools.ts`):
+ *   generate_schematic_from_description →
+ *     { status:'generated', kind:'schematic', design_name, schFiles:[{filename}],
+ *       schArtifacts:[{id,type,filename,size}], kicadPro, project_achieve_url, note? }
+ *   generate_system_module_graph →
+ *     { status:'generated', kind:'system', design_name, module_count,
+ *       connection_count, module_names, zip_bytes,
+ *       zipArtifact:{id,type:'zip',filename,size}, note? }
+ *   both may return { status:'needs_auth', kind, hint }
+ */
+
+export interface ContentBlockLike {
+  type?: string
+  text?: string
+}
+
+export interface ToolBlockLike {
+  content?: readonly ContentBlockLike[]
+  isError?: boolean
+  error?: { code?: string } | null
+}
+
+export interface ArtifactRef {
+  id: string
+  type: string | null
+  filename: string | null
+  size: number | null
+}
+
+export interface SchResult {
+  status: string | null
+  kind: string | null
+  artifact: ArtifactRef | null
+  designName: string | null
+  fileCount: number | null
+  moduleCount: number | null
+  connectionCount: number | null
+  /** User-safe status detail — rendered by the card. */
+  note: string | null
+  /**
+   * Agent-only directive/explanation. Parsed only so the shape is explicit;
+   * the card deliberately never renders it.
+   */
+  agentNote: string | null
+}
+
+export type ProjectedPhase =
+  | { phase: 'generating' }
+  | { phase: 'failed'; message: string }
+  | { phase: 'needs_auth'; result: SchResult }
+  | { phase: 'completed'; result: SchResult }
+  | { phase: 'unknown' }
+
+export function resultTextOf(block: ToolBlockLike | undefined): string {
+  const content = block?.content
+  if (!Array.isArray(content)) return ''
+  for (const c of content) {
+    if (c && c.type === 'text' && typeof c.text === 'string') return c.text
+  }
+  return ''
+}
+
+function firstLine(text: string): string {
+  const t = text.trim()
+  const nl = t.indexOf('\n')
+  return nl === -1 ? t : t.slice(0, nl)
+}
+
+function artOf(a: unknown): ArtifactRef | null {
+  if (!a || typeof a !== 'object') return null
+  const o = a as Record<string, unknown>
+  const id = typeof o.id === 'string' ? o.id : null
+  if (!id) return null
+  return {
+    id,
+    type: typeof o.type === 'string' ? o.type : null,
+    filename: typeof o.filename === 'string' ? o.filename : null,
+    size: typeof o.size === 'number' ? o.size : null,
+  }
+}
+
+export function parseSchResult(text: string): SchResult | null {
+  const t = text.trim()
+  if (!t) return null
+  let v: unknown
+  try {
+    v = JSON.parse(t)
+  } catch {
+    return null
+  }
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return null
+  const o = v as Record<string, unknown>
+
+  const status = typeof o.status === 'string' ? o.status : null
+  const kind = typeof o.kind === 'string' ? o.kind : null
+
+  let artifact: ArtifactRef | null = null
+  if (kind === 'system') {
+    artifact = artOf(o.zipArtifact)
+  } else {
+    const list = Array.isArray(o.schArtifacts) ? (o.schArtifacts as unknown[]) : []
+    artifact = list.length > 0 ? artOf(list[0]) : null
+  }
+
+  return {
+    status,
+    kind,
+    artifact,
+    designName: typeof o.design_name === 'string' && o.design_name ? o.design_name : null,
+    fileCount: Array.isArray(o.schFiles) ? (o.schFiles as unknown[]).length
+      : (Array.isArray(o.schArtifacts) ? (o.schArtifacts as unknown[]).length : null),
+    moduleCount: typeof o.module_count === 'number' ? o.module_count : null,
+    connectionCount: typeof o.connection_count === 'number' ? o.connection_count : null,
+    note: typeof o.note === 'string' ? o.note : null,
+    agentNote: typeof o.agentNote === 'string' ? o.agentNote : null,
+  }
+}
+
+export function projectToolCall(block: ToolBlockLike | undefined): ProjectedPhase {
+  if (!block || typeof block !== 'object') return { phase: 'unknown' }
+  if (!Array.isArray(block.content)) return { phase: 'generating' }
+  if (block.isError === true) {
+    const errText = resultTextOf(block)
+    const errCode = block.error && typeof block.error.code === 'string' ? block.error.code : null
+    return { phase: 'failed', message: firstLine(errText) || (errCode ? `tool error: ${errCode}` : 'generation failed') }
+  }
+  const text = resultTextOf(block)
+  const parsed = parseSchResult(text)
+  if (!parsed) return { phase: 'failed', message: firstLine(text) || 'unparseable tool result' }
+  if (parsed.status === 'generated') return { phase: 'completed', result: parsed }
+  if (parsed.status === 'needs_auth') return { phase: 'needs_auth', result: parsed }
+  if (parsed.kind) return { phase: 'completed', result: parsed }
+  return { phase: 'failed', message: `unexpected tool status: ${parsed.status}` }
+}
+
+export function formatBytes(n: number | null): string {
+  if (typeof n !== 'number' || !Number.isFinite(n) || n < 0) return ''
+  if (n < 1024) return `${n} B`
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`
+}
+
+/** Filename for download: prefer the artifact filename, else derive from kind. */
+export function downloadFilenameFor(kind: string | null, artifact: ArtifactRef | null, designName: string | null): string {
+  if (artifact?.filename) return artifact.filename
+  const base = designName && designName.length > 0 ? designName : 'generated'
+  if (kind === 'system') return `${base}.zip`
+  if (kind === 'schematic') return `${base}.kicad_sch`
+  return `${base}.txt`
+}