@guanlin4924/devflow-pi 0.1.40 → 0.1.48

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/wireframe_commit.rb

@@ -0,0 +1,222 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Core-owned persistence for wireframe canonical metadata and approval.
+require "digest"
+require "json"
+require "open3"
+require "optparse"
+require "time"
+require "yaml"
+require_relative "control_io"
+
+BUSINESS_VALIDATOR = File.expand_path("business_model_validate.py", __dir__)
+
+options = {
+  action: "meta",
+  feature: nil,
+  canonical: nil,
+  state: ".planning/STATE.md",
+  expected_revision: nil,
+  confirmed_screens: nil,
+  approved_by: nil,
+  runtime_confirmed: false,
+  all_screens: false,
+  write: false,
+  json: false,
+  business_canonical: nil
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: wireframe_commit.rb --action meta|approve --feature NAME --write"
+  opts.on("--action ACTION", %w[meta approve]) { |value| options[:action] = value }
+  opts.on("--feature NAME") { |value| options[:feature] = value }
+  opts.on("--canonical PATH") { |value| options[:canonical] = value }
+  opts.on("--state PATH") { |value| options[:state] = value }
+  opts.on("--expected-revision REVISION", Integer) { |value| options[:expected_revision] = value }
+  opts.on("--confirmed-screens IDS", "Comma-separated screen IDs") { |value| options[:confirmed_screens] = value }
+  opts.on("--approved-by ACTOR") { |value| options[:approved_by] = value }
+  opts.on("--runtime-confirmed", "Internal runtime authorization for user confirmation") { options[:runtime_confirmed] = true }
+  opts.on("--all-screens", "Internal runtime confirmation of the current canonical screen set") { options[:all_screens] = true }
+  opts.on("--write") { options[:write] = true }
+  opts.on("--json") { options[:json] = true }
+  opts.on("--business-canonical PATH") { |value| options[:business_canonical] = value }
+end.parse!
+
+ROOT = Dir.pwd
+
+def front_matter(markdown)
+  match = markdown.match(/\A---\n(.*?)\n---\n/m)
+  match && match[1]
+end
+
+def load_state(path)
+  yaml = front_matter(File.read(path))
+  raise ArgumentError, "missing state front matter" if yaml.nil?
+
+  YAML.safe_load(yaml, permitted_classes: [], aliases: false)
+end
+
+ROOT_ORDER = %w[schema_version feature screens].freeze
+SCREEN_ORDER = %w[id title presentation platforms requirement_refs elements actions states].freeze
+ELEMENT_ORDER = %w[id type title label action_refs action_ref fields columns items tabs].freeze
+ACTION_ORDER = %w[id type target].freeze
+INLINE_ORDER = %w[id label type title meta value action_ref].freeze
+
+def canonical_reorder(value, order = INLINE_ORDER)
+  return value.map { |item| canonical_reorder(item, INLINE_ORDER) } if value.is_a?(Array)
+  return value unless value.is_a?(Hash)
+
+  keys = order.select { |key| value.key?(key) }
+  keys += value.keys.map(&:to_s).reject { |key| keys.include?(key) }.sort
+  keys.each_with_object({}) { |key, result| result[key] = canonical_reorder(value[key], INLINE_ORDER) }
+end
+
+def canonical_normalize(value)
+  return value.unicode_normalize(:nfkc).rstrip if value.is_a?(String)
+  return value.map { |item| canonical_normalize(item) } if value.is_a?(Array)
+  return value unless value.is_a?(Hash)
+
+  value.each_with_object({}) do |(key, item), result|
+    result[key] = canonical_normalize(item)
+  end
+end
+
+def canonical_order(canonical)
+  root = ROOT_ORDER.select { |key| canonical.key?(key) }
+  root += canonical.keys.map(&:to_s).reject { |key| root.include?(key) }.sort
+  root.each_with_object({}) do |key, result|
+    order = key == "screens" ? SCREEN_ORDER : ROOT_ORDER
+    result[key] = if key == "screens"
+                    Array(canonical[key]).map do |screen|
+                      canonical_reorder(screen, SCREEN_ORDER).tap do |ordered|
+                        ordered["elements"] = Array(screen["elements"]).map { |element| canonical_reorder(element, ELEMENT_ORDER) }
+                        ordered["actions"] = Array(screen["actions"]).map { |action| canonical_reorder(action, ACTION_ORDER) }
+                      end
+                    end
+                  else
+                    canonical_reorder(canonical[key], order)
+                  end
+  end
+end
+
+def canonical_fingerprint(canonical)
+  normalized = canonical_normalize(canonical)
+  encoded = JSON.generate(canonical_order(normalized)) + "\n"
+  "sha256:#{Digest::SHA256.hexdigest(encoded)}"
+end
+
+def read_source_fingerprint(root, feature)
+  path = File.join(root, ".planning", "requirements", feature, "traceability.json")
+  return "" unless File.file?(path)
+
+  JSON.parse(File.read(path))["source_document_fingerprint"].to_s
+end
+
+def verify_business_action_refs(canonical, path)
+  business = JSON.parse(File.read(path))
+  action_ids = Array(business["actions"]).select { |item| item.is_a?(Hash) }.map { |item| item["id"].to_s }
+  Array(canonical["screens"]).each do |screen|
+    Array(screen["actions"]).each do |action|
+      next unless action.is_a?(Hash) && action["type"].to_s == "open"
+      ref = action["business_action_ref"].to_s
+      raise ArgumentError, "business_action_ref is required for open action #{action['id']}" if ref.empty?
+      raise ArgumentError, "business action reference is unresolved: #{ref}" unless action_ids.include?(ref)
+    end
+  end
+rescue JSON::ParserError => e
+  raise ArgumentError, "invalid business canonical JSON: #{e.message}"
+end
+
+def business_fingerprint(path)
+  stdout, stderr, status = Open3.capture3("python3", BUSINESS_VALIDATOR, "--proposal", path.to_s)
+  raise ArgumentError, "business canonical validation failed: #{stderr.strip}" unless status.success?
+
+  JSON.parse(stdout).fetch("canonical_fingerprint")
+rescue JSON::ParserError, KeyError => error
+  raise ArgumentError, "invalid business canonical validator output: #{error.message}"
+end
+
+def result_payload(value, options)
+  puts(options[:json] ? JSON.pretty_generate(value) : (value["message"] || (value["ok"] ? "ok" : "failed")))
+end
+
+project_lock = nil
+begin
+  raise ArgumentError, "feature is required" if options[:feature].to_s.empty?
+  raise ArgumentError, "--write is required" unless options[:write]
+  raise ArgumentError, "--expected-revision is required" if options[:expected_revision].nil?
+  if options[:action] == "approve"
+    raise ArgumentError, "--approved-by is required" if options[:approved_by].to_s.empty?
+    raise ArgumentError, "--runtime-confirmed is required for approval" unless options[:runtime_confirmed]
+  end
+
+  canonical_relative = options[:canonical] || ".planning/features/#{options[:feature]}/canonical.json"
+  state_absolute, = DevflowControlIO.resolve_control_path(ROOT, options[:state], :state)
+  canonical_absolute, canonical_path = DevflowControlIO.resolve_control_path(ROOT, canonical_relative, :artifact)
+  raise ArgumentError, "canonical.json does not exist" unless File.file?(canonical_absolute)
+
+  project_lock = DevflowControlIO.acquire_project_lock(ROOT)
+  state = load_state(state_absolute)
+  raise ArgumentError, "state feature mismatch" unless state["current_feature"].to_s == options[:feature].to_s
+  unless state["revision"].to_i == options[:expected_revision]
+    raise ArgumentError, "state revision mismatch: expected #{options[:expected_revision]}, got #{state["revision"]}"
+  end
+
+  canonical = JSON.parse(File.read(canonical_absolute))
+  raise ArgumentError, "canonical feature mismatch" unless canonical["feature"].to_s == options[:feature].to_s
+  business_fingerprint_value = nil
+  if options[:business_canonical]
+    business_absolute, = DevflowControlIO.resolve_control_path(ROOT, options[:business_canonical], :artifact)
+    verify_business_action_refs(canonical, business_absolute)
+    business_fingerprint_value = business_fingerprint(business_absolute)
+  end
+  prototype_fingerprint = canonical_fingerprint(canonical)
+  source_fingerprint = read_source_fingerprint(ROOT, options[:feature])
+  raise ArgumentError, "source_document_fingerprint is required" if source_fingerprint.empty?
+
+  screen_ids = Array(canonical["screens"]).map { |screen| screen["id"].to_s }.sort
+  meta_path = File.join(ROOT, ".planning", "features", options[:feature], "canonical.meta.json")
+  meta = {
+    "schema_version" => 1,
+    "feature" => options[:feature],
+    "canonical_path" => canonical_path,
+    "prototype_fingerprint" => prototype_fingerprint,
+    "source_document_fingerprint" => source_fingerprint,
+    "business_prototype_fingerprint" => business_fingerprint_value,
+    "state_revision" => state["revision"],
+    "built_by" => "devflow-core/wireframe-commit",
+    "built_at" => Time.now.utc.iso8601
+  }
+  DevflowControlIO.atomic_write(meta_path, JSON.pretty_generate(meta) + "\n")
+  output = { "ok" => true, "action" => "meta", "meta" => meta }
+
+  if options[:action] == "approve"
+    confirmed = options[:all_screens] ? screen_ids : options[:confirmed_screens].to_s.split(",").map(&:strip).reject(&:empty?).sort
+    raise ArgumentError, "--confirmed-screens is required" if confirmed.empty?
+    raise ArgumentError, "confirmed screen set does not match canonical" unless confirmed == screen_ids
+
+    approval = {
+      "schema_version" => 1,
+      "feature" => options[:feature],
+      "status" => "approved",
+      "prototype_fingerprint" => prototype_fingerprint,
+      "source_document_fingerprint" => source_fingerprint,
+      "business_prototype_fingerprint" => business_fingerprint_value,
+      "state_revision" => state["revision"],
+      "confirmed_screens" => confirmed,
+      "approved_by" => options[:approved_by],
+      "approved_at" => Time.now.utc.iso8601
+    }
+    approval_path = File.join(ROOT, ".planning", "features", options[:feature], "approval.json")
+    DevflowControlIO.atomic_write(approval_path, JSON.pretty_generate(approval) + "\n")
+    output["action"] = "approve"
+    output["approval"] = approval
+  end
+  result_payload(output, options)
+rescue StandardError => error
+  result_payload({ "ok" => false, "reason" => "wireframe_commit_failed", "message" => error.message }, options)
+  exit 1
+ensure
+  DevflowControlIO.release_lock(project_lock)
+end

package/plugins/devflow-core/skills/workflow-orchestrator/scripts/wireframe_render.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python3
+"""Deterministic low-fidelity Markdown/SVG renderer and static gallery builder."""
+from __future__ import annotations
+
+import argparse
+import base64
+import hashlib
+import html
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import sys
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from wireframe_validate import canonical_order, normalize  # type: ignore
+
+
+def esc(value: Any) -> str:
+    return html.escape(str(value), quote=True)
+
+
+def text(value: Any, default: str = "") -> str:
+    return esc(value if value is not None else default)
+
+
+def svg_text(x: int, y: int, value: Any, size: int = 13, fill: str = "#0f172a", weight: str = "400") -> str:
+    return f'<text x="{x}" y="{y}" font-size="{size}" fill="{fill}" font-weight="{weight}">{text(value)}</text>'
+
+
+def gfm_cell(value: Any) -> str:
+    return str(value if value is not None else "").replace("\\", "\\\\").replace("|", "\\|").replace("\r\n", "<br>").replace("\n", "<br>")
+
+
+def mermaid_label(value: Any) -> str:
+    return (str(value if value is not None else "")
+            .replace("&", "#38;")
+            .replace('"', "#quot;")
+            .replace("[", "#91;")
+            .replace("]", "#93;")
+            .replace("\r", " ").replace("\n", " "))
+
+
+def render_screen(screen: dict[str, Any], platform: str) -> str:
+    mobile = platform == "mobile"
+    width, height = (390, 760) if mobile else (960, 600)
+    pad = 20 if mobile else 48
+    pieces = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}" role="img" aria-label="{text(screen.get("title"))} {platform} 页面线框">', f'<rect width="{width}" height="{height}" fill="#f8fafc"/>']
+    y = 45 if mobile else 58
+    if screen.get("presentation") in {"modal", "drawer"}:
+        if mobile:
+            panel_x, panel_y, panel_w, panel_h = 0, 220, width, height - 220
+            pad, y = 24, 265
+        elif screen.get("presentation") == "drawer":
+            panel_x, panel_y, panel_w, panel_h = 540, 0, 420, height
+            pad, y = 570, 48
+        else:
+            panel_x, panel_y, panel_w, panel_h = 270, 70, 420, 460
+            pad, y = 300, 115
+        pieces.append(f'<rect width="{width}" height="{height}" fill="#0f172a33"/>')
+        pieces.append(f'<rect x="{panel_x}" y="{panel_y}" width="{panel_w}" height="{panel_h}" rx="12" fill="white" stroke="#7c3aed" stroke-width="2"/>')
+        content_right = panel_x + panel_w - (24 if mobile else 30)
+    else:
+        content_right = width - pad
+    content_width = content_right - pad
+    for element in screen.get("elements", []):
+        typ = element.get("type")
+        if typ == "page_header":
+            pieces.append(svg_text(pad, y, element.get("title", screen.get("title")), 21 if mobile else 25, weight="700"))
+            y += 48
+        elif typ == "filter_bar":
+            box_h = 92 if mobile else 76
+            pieces.append(f'<rect x="{pad}" y="{y}" width="{content_width}" height="{box_h}" rx="8" fill="white" stroke="#cbd5e1"/>')
+            fields = element.get("fields", [])
+            for i, field in enumerate(fields[:2]):
+                x = pad + 16 if mobile else pad + 24 + i * 220
+                pieces.append(svg_text(x, y + 28, field.get("label"), 12, "#64748b"))
+                pieces.append(f'<rect x="{x}" y="{y + 38}" width="{150 if mobile else 180}" height="24" fill="#f1f5f9" stroke="#cbd5e1"/>')
+            y += box_h + 22
+        elif typ == "table":
+            box_h = 290 if mobile else 300
+            pieces.append(f'<rect x="{pad}" y="{y}" width="{content_width}" height="{box_h}" rx="8" fill="white" stroke="#cbd5e1"/>')
+            columns = element.get("columns", [])
+            if mobile:
+                pieces.append(svg_text(pad + 16, y + 36, "列表", 14, weight="700"))
+                for row, label in enumerate(["示例任务一", "示例任务二"]):
+                    ry = y + 78 + row * 72
+                    pieces.extend([svg_text(pad + 16, ry, label), svg_text(pad + 16, ry + 24, "运行中 · 2026-09-01", 12, "#64748b"), f'<path d="M{pad + 16} {ry + 38} H{width - pad - 16}" stroke="#e2e8f0"/>'])
+            else:
+                for i, col in enumerate(columns):
+                    pieces.append(svg_text(pad + 24 + i * 160, y + 36, col.get("label"), 13, "#475569"))
+                for row in range(4):
+                    ry = y + 74 + row * 54
+                    pieces.append(f'<path d="M{pad + 16} {ry} H{content_right - 16}" stroke="#e2e8f0"/>')
+                    if row < 2:
+                        pieces.extend([svg_text(pad + 24, ry + 32, "示例任务"), svg_text(pad + 184, ry + 32, "运行中"), svg_text(pad + 344, ry + 32, "2026-09-01"), svg_text(pad + 504, ry + 32, "查看", 13, "#2563eb")])
+            y += box_h + 22
+        elif typ == "card_list":
+            for item in element.get("items", []):
+                pieces.append(f'<rect x="{pad}" y="{y}" width="{width - 2 * pad}" height="90" rx="8" fill="white" stroke="#cbd5e1"/>')
+                pieces.append(svg_text(pad + 20, y + 34, item.get("title"), 14, weight="700"))
+                meta = item.get("meta", [])
+                pieces.append(svg_text(pad + 20, y + 62, " · ".join(f'{m.get("label")}: {m.get("value")}' for m in meta), 12, "#64748b"))
+                y += 108
+        elif typ == "tabs":
+            pieces.append(f'<rect x="{pad}" y="{y}" width="{content_width}" height="48" fill="white" stroke="#cbd5e1"/>')
+            for i, tab in enumerate(element.get("tabs", [])):
+                pieces.append(svg_text(pad + 20 + i * 120, y + 30, tab.get("label"), 14, "#2563eb" if i == 0 else "#64748b"))
+            y += 70
+        elif typ == "bottom_navigation":
+            bar_h = 58
+            bar_y = height - bar_h - 18
+            pieces.append(f'<rect x="{pad}" y="{bar_y}" width="{content_width}" height="{bar_h}" rx="8" fill="white" stroke="#cbd5e1"/>')
+            items = element.get("items", [])
+            slot = max(1, (width - 2 * pad) // max(1, len(items)))
+            for i, item in enumerate(items):
+                pieces.append(f'<text x="{pad + slot * i + slot // 2}" y="{bar_y + 35}" text-anchor="middle" font-size="12" fill="#475569">{text(item.get("label"))}</text>')
+        elif typ in {"input", "select"}:
+            pieces.append(svg_text(pad, y, element.get("label"), 12, "#64748b"))
+            pieces.append(f'<rect x="{pad}" y="{y + 10}" width="{content_width}" height="38" fill="white" stroke="#cbd5e1"/>')
+            y += 70
+        elif typ in {"button", "icon_button"}:
+            bw = 150 if mobile else 140
+            pieces.append(f'<rect x="{pad}" y="{y}" width="{bw}" height="40" rx="5" fill="#334155"/>')
+            pieces.append(f'<text x="{pad + bw // 2}" y="{y + 26}" text-anchor="middle" font-size="13" fill="white">{text(element.get("label"))}</text>')
+            y += 58
+    pieces.append("</svg>")
+    return "".join(pieces)
+
+
+def render_flow(screens: list[dict[str, Any]]) -> str:
+    width = max(760, 220 * len(screens) + 80)
+    parts = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="180" viewBox="0 0 {width} 180" role="img" aria-label="页面流转图"><defs><marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto"><path d="M0,0 L8,4 L0,8 Z" fill="#64748b"/></marker></defs><rect width="100%" height="100%" fill="#f8fafc"/>']
+    ids = {s.get("id"): i for i, s in enumerate(screens)}
+    for i, screen in enumerate(screens):
+        x = 40 + i * 220
+        modal = screen.get("presentation") in {"modal", "drawer"}
+        shape = f'<path d="M{x + 90} 62 L{x + 180} 90 L{x + 90} 118 L{x} 90 Z"' if modal else f'<rect x="{x}" y="62" width="180" height="56" rx="8"'
+        parts.append(shape + ' fill="#fff" stroke="#334155" stroke-width="2"/>')
+        parts.append(f'<text x="{x + 90}" y="96" text-anchor="middle" font-family="Arial,sans-serif" font-size="14" fill="#0f172a">{mermaid_label(screen.get("title"))}</text>')
+        for action in screen.get("actions", []):
+            if action.get("type") == "open" and action.get("target") in ids:
+                tx = 40 + ids[action["target"]] * 220
+                parts.append(f'<path d="M{x + 180} 90 H{tx}" stroke="#64748b" stroke-width="2" marker-end="url(#arrow)"/>')
+    parts.append("</svg>")
+    return "".join(parts)
+
+
+def render_preview(screens: list[dict[str, Any]], feature: str) -> str:
+    lines = [f"# 低保真原型：{feature}", "", "> 此文件由 canonical.json 确定性生成，仅用于结构审查。", "", "## 页面流转", "", "```mermaid", "flowchart LR"]
+    for screen in screens:
+        sid = screen["id"].replace("-", "_")
+        lines.append(f'  {sid}["{mermaid_label(screen["title"])}"]')
+    for screen in screens:
+        for action in screen.get("actions", []):
+            if action.get("type") == "open":
+                lines.append(f'  {screen["id"].replace("-", "_")} -->|{mermaid_label(action.get("id", "open"))}| {action["target"].replace("-", "_")}')
+    lines += ["```", "", "## Screens", ""]
+    for screen in screens:
+        lines += [f'### {screen["title"]} (`{screen["id"]}`)', "", f'- presentation: `{screen.get("presentation", "page")}`', f'- platforms: `{", ".join(screen.get("platforms", ["web", "mobile"]))}`', f'- states: `{", ".join(screen.get("states", []))}`', "", "| 顺序 | 元素 ID | 类型 | 内容 |", "|---:|---|---|---|"]
+        for i, element in enumerate(screen.get("elements", []), 1):
+            payload = element.get("label") or element.get("title") or element.get("type")
+            if element.get("fields"): payload = ", ".join(f.get("label", "") for f in element["fields"])
+            if element.get("columns"): payload = ", ".join(c.get("label", "") for c in element["columns"])
+            if element.get("items"): payload = ", ".join(item.get("title", "") for item in element["items"])
+            if element.get("type") == "bottom_navigation" and element.get("items"):
+                payload = ", ".join(item.get("label", "") for item in element["items"])
+            lines.append(f'| {i} | `{gfm_cell(element["id"])}` | `{gfm_cell(element["type"])}` | {gfm_cell(payload)} |')
+        lines += ["", "#### Actions", "", "| ID | Type | Target |", "|---|---|---|"]
+        for action in screen.get("actions", []):
+            lines.append(f'| `{gfm_cell(action["id"])}` | `{gfm_cell(action["type"])}` | `{gfm_cell(action.get("target") or "null")}` |')
+        lines.append("")
+    return "\n".join(lines)
+
+
+def data_uri(svg: str) -> str:
+    return "data:image/svg+xml;base64," + base64.b64encode(svg.encode("utf-8")).decode("ascii")
+
+
+def gallery_html(manifest: dict[str, Any], assets: dict[str, str], standalone: bool) -> str:
+    manifest_json = json.dumps(manifest, ensure_ascii=False, separators=(",", ":"))
+    # script is a raw-text element: HTML entities would remain literal and
+    # break JSON.parse. Escape only characters that could terminate the tag.
+    embedded_manifest = manifest_json.replace("&", "\\u0026").replace("<", "\\u003c").replace(">", "\\u003e")
+    asset_json = json.dumps(assets, ensure_ascii=False, separators=(",", ":"))
+    return f'''<!doctype html><meta charset="utf-8"><title>Wireframe Gallery</title>
+<style>body{{margin:0;background:#eef2f7;color:#0f172a;font:14px system-ui,sans-serif}}header{{padding:18px 24px;background:#fff;border-bottom:1px solid #cbd5e1}}main{{display:flex;min-height:calc(100vh - 70px)}}aside{{width:190px;padding:20px;background:#f8fafc;border-right:1px solid #cbd5e1}}button{{display:block;width:100%;margin:0 0 8px;padding:10px;text-align:left;border:1px solid #cbd5e1;border-radius:6px;background:#fff;cursor:pointer}}button.active{{border-color:#7c3aed;background:#f3e8ff}}section{{flex:1;padding:24px}}.toolbar{{display:flex;gap:8px;margin-bottom:18px}}.toolbar button{{width:auto}}.frame{{padding:20px;background:#dbe3ed;border-radius:10px;min-height:620px}}.frame img{{display:block;max-width:100%;max-height:620px;margin:auto;box-shadow:0 8px 24px #94a3b855;background:#fff}}.meta{{color:#64748b;font-size:12px;margin-top:12px}}</style>
+<script type="application/json" id="gallery-manifest">{embedded_manifest}</script>
+<header><strong>低保真原型画廊</strong><div class="meta">prototype: {esc(manifest['prototype_fingerprint'])} · source: {esc(manifest['source_document_fingerprint'])} · renderer: {esc(manifest['renderer_version'])}</div></header>
+<main><aside id="nav"></aside><section><div class="toolbar"><button id="web">Web</button><button id="mobile">Mobile</button><button id="flow">流程图</button></div><div class="frame"><img id="preview" alt="页面线框"></div><div class="meta" id="state">state: default</div></section></main>
+<script>const manifest=JSON.parse(document.querySelector('#gallery-manifest').textContent);const assets={asset_json};let current=manifest.screens[0].screen_id,platform='web';const nav=document.querySelector('#nav'),img=document.querySelector('#preview'),webBtn=document.querySelector('#web'),mobileBtn=document.querySelector('#mobile');function path(id,p){{const s=manifest.screens.find(x=>x.screen_id===id);return s&&s.platforms[p]&&s.platforms[p].states.default}}manifest.screens.forEach(s=>{{const b=document.createElement('button');b.textContent=s.screen_id;b.dataset.id=s.screen_id;b.onclick=()=>{{current=s.screen_id;render()}};nav.append(b)}});function render(){{document.querySelectorAll('aside button').forEach(b=>b.classList.toggle('active',b.dataset.id===current));const s=manifest.screens.find(x=>x.screen_id===current);webBtn.disabled=!s.platforms.web;mobileBtn.disabled=!s.platforms.mobile;const p=path(current,platform);if(p){{img.src=assets[p]||p;img.alt=current+' '+platform+' default'}}else{{img.removeAttribute('src');img.alt=current+' '+platform+' 未定义'}}}}webBtn.onclick=()=>{{platform='web';render()}};mobileBtn.onclick=()=>{{platform='mobile';render()}};document.querySelector('#flow').onclick=()=>{{img.src=assets['flow.svg']||'flow.svg'}};render()</script>'''
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--canonical", required=True, type=Path)
+    parser.add_argument("--out", required=True, type=Path)
+    parser.add_argument("--source-fingerprint", required=True)
+    parser.add_argument("--mode", choices=["folder", "standalone", "both"], default="both")
+    args = parser.parse_args()
+    canonical = json.loads(args.canonical.read_text(encoding="utf-8"))
+    screens = canonical.get("screens", [])
+    canonical_bytes = json.dumps(canonical_order(normalize(canonical)), ensure_ascii=False, separators=(",", ":")) + "\n"
+    prototype = "sha256:" + hashlib.sha256(canonical_bytes.encode("utf-8")).hexdigest()
+    manifest: dict[str, Any] = {"prototype_fingerprint": prototype, "source_document_fingerprint": args.source_fingerprint, "renderer_version": "1.0.0", "generated_at": datetime.now(timezone.utc).isoformat(), "screens": []}
+    assets: dict[str, str] = {}
+    svg_by_path: dict[str, str] = {"flow.svg": render_flow(screens)}
+    for screen in screens:
+        entry = {"screen_id": screen["id"], "platforms": {}}
+        for platform in screen.get("platforms", ["web", "mobile"]):
+            path = f"screens/{screen['id']}/{platform}/default.svg"
+            svg_by_path[path] = render_screen(screen, platform)
+            entry["platforms"][platform] = {"states": {"default": path}}
+        manifest["screens"].append(entry)
+    args.out.mkdir(parents=True, exist_ok=True)
+    (args.out / "preview.md").write_text(render_preview(screens, canonical.get("feature", "wireframe")), encoding="utf-8")
+    if args.mode in {"folder", "both"}:
+        for path, content in svg_by_path.items():
+            target = args.out / path
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(content, encoding="utf-8")
+        (args.out / "gallery-manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        (args.out / "wireframes.html").write_text(gallery_html(manifest, {path: path for path in svg_by_path}, False), encoding="utf-8")
+    if args.mode in {"standalone", "both"}:
+        standalone_assets = {path: data_uri(content) for path, content in svg_by_path.items()}
+        (args.out / "wireframes-standalone.html").write_text(gallery_html(manifest, standalone_assets, True), encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())