@fieldwangai/agentflow 0.1.126 → 0.1.129

package/bin/lib/prd-workflow-collaboration.mjs

@@ -105,6 +105,14 @@ export function getPrdWorkflowCollaborationForUser(tapdId, userId) {
   return records.find((record) => record.ownerId === actorId) || records[0] || null;
 }
 
+export function listPrdWorkflowCollaborationsForUser(userId) {
+  const actorId = normalizeUserId(userId);
+  if (!actorId) return [];
+  return Object.values(readRegistry().workflows)
+    .filter((record) => prdWorkflowCollaborationAccess(record, actorId).allowed)
+    .sort((left, right) => String(right?.updatedAt || "").localeCompare(String(left?.updatedAt || "")));
+}
+
 export function ensurePrdWorkflowCollaboration({ tapdId, userId }) {
   const ownerId = normalizeUserId(userId);
   const normalizedTapdId = normalizeTapdId(tapdId);

package/bin/lib/ui-server.mjs

@@ -156,6 +156,7 @@ import {
   getPrdWorkflowCollaborationByShareToken,
   getPrdWorkflowCollaborationForUser,
   ensurePrdWorkflowShareLink,
+  listPrdWorkflowCollaborationsForUser,
   prdWorkflowCollaborationAccess,
   prdWorkflowCollaborationSummary,
   removePrdWorkflowCollaborationMember,
@@ -3349,6 +3350,123 @@ function prdWorkflowShareLinkSummary(record, shareToken, publicBaseUrl, userId =
   };
 }
 
+function prdWorkflowDashboardActions(snapshot = {}) {
+  const rows = new Map();
+  for (const field of ["actions", "workflowActions", "workflow_actions", "timeline", "history"]) {
+    for (const item of Array.isArray(snapshot?.[field]) ? snapshot[field] : []) {
+      if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+      const key = String(
+        item.stageKey
+        || item.stage_key
+        || item.actionId
+        || item.action_id
+        || item.id
+        || item.action
+        || "",
+      ).trim();
+      if (!key) continue;
+      rows.set(key, { ...(rows.get(key) || {}), ...item });
+    }
+  }
+  return Array.from(rows.values());
+}
+
+function prdWorkflowDashboardTimestamp(item = {}) {
+  for (const value of [
+    item.updatedAt,
+    item.updated_at,
+    item.observedAt,
+    item.observed_at,
+    item.completedAt,
+    item.completed_at,
+    item.stageEnteredAt,
+    item.stage_entered_at,
+    item.actionAt,
+    item.action_at,
+    item.startedAt,
+    item.started_at,
+    item.reportedAt,
+    item.reported_at,
+    item.createdAt,
+    item.created_at,
+    item.at,
+  ]) {
+    const timestamp = Date.parse(String(value || ""));
+    if (Number.isFinite(timestamp)) return timestamp;
+  }
+  return 0;
+}
+
+function prdWorkflowDashboardSummary(record, snapshot = {}, userCtx = {}) {
+  const tapdId = String(record?.tapdId || snapshot?.tapdId || snapshot?.tapd_id || "").trim();
+  const collaboration = prdWorkflowCollaborationSummaryWithUsers(record, userCtx?.userId) || {};
+  const actions = prdWorkflowDashboardActions(snapshot);
+  const doneStatuses = new Set(["done", "complete", "success", "completed", "passed", "observed"]);
+  const completedActions = actions.filter((item) => (
+    doneStatuses.has(String(item?.status || "").trim().toLowerCase())
+  )).length;
+  const latestAction = [...actions].sort((left, right) => (
+    prdWorkflowDashboardTimestamp(right) - prdWorkflowDashboardTimestamp(left)
+  ))[0] || null;
+  const issues = Array.isArray(snapshot?.issues)
+    ? snapshot.issues
+    : Array.isArray(snapshot?.raw?.prd?.issues)
+      ? snapshot.raw.prd.issues
+      : [];
+  const platforms = Array.from(new Set(issues
+    .map((issue) => String(issue?.platform || "").trim().toLowerCase())
+    .filter(Boolean)));
+  const phase = String(snapshot?.phase || "").trim();
+  const phaseKey = phase.toLowerCase();
+  const state = /blocked|failed|error|conflict/.test(phaseKey)
+    ? "blocked"
+    : /done|completed|released|closed/.test(phaseKey) || (actions.length > 0 && completedActions === actions.length)
+      ? "completed"
+      : "active";
+  const requirement = snapshot?.overall?.requirement && typeof snapshot.overall.requirement === "object"
+    ? snapshot.overall.requirement
+    : {};
+  const title = String(
+    requirement.title
+    || requirement.name
+    || snapshot?.prd?.title
+    || snapshot?.raw?.prd?.title
+    || snapshot?.title
+    || "",
+  ).trim();
+  const updatedAtTimestamp = Math.max(
+    prdWorkflowDashboardTimestamp(record),
+    prdWorkflowDashboardTimestamp(snapshot),
+    prdWorkflowDashboardTimestamp(latestAction || {}),
+  );
+  return {
+    id: String(record?.id || ""),
+    tapdId,
+    title,
+    phase,
+    state,
+    pointer: String(snapshot?.pointer || "").trim(),
+    revision: String(snapshot?.revision || "").trim(),
+    issueCount: issues.length,
+    platforms,
+    actionCount: actions.length,
+    completedActionCount: completedActions,
+    latestAction: latestAction
+      ? {
+          title: String(latestAction.title || latestAction.label || latestAction.action || latestAction.id || "").trim(),
+          status: String(latestAction.status || "").trim(),
+          at: prdWorkflowDashboardTimestamp(latestAction) ? new Date(prdWorkflowDashboardTimestamp(latestAction)).toISOString() : "",
+        }
+      : null,
+    role: String(collaboration.role || ""),
+    ownerId: String(collaboration.ownerId || ""),
+    ownerUsername: String(collaboration.ownerUsername || collaboration.ownerId || ""),
+    memberCount: Number(collaboration.memberCount || 0),
+    shareActive: collaboration.shareActive === true,
+    updatedAt: updatedAtTimestamp ? new Date(updatedAtTimestamp).toISOString() : String(record?.updatedAt || ""),
+  };
+}
+
 function workspaceConversationsPath(scopedRoot) {
   return path.join(path.resolve(scopedRoot), ".workspace", "agentflow", "conversations.json");
 }
@@ -8372,6 +8490,111 @@ function prdWorkflowReviewRenderPlannedCode(filePath, codeLines, startLine = 0,
 </section>`;
 }
 
+const PRD_WORKFLOW_VERIFICATION_FIELDS = {
+  "入口": "entry",
+  "前置条件": "precondition",
+  "观察": "observation",
+  "通过标准": "passCriteria",
+};
+
+function prdWorkflowReviewVerificationBoundary(line) {
+  const trimmed = String(line || "").trim();
+  return /^#verification\s*$/i.test(trimmed)
+    || /^#change\s+(?:add|modify|remove|move)\s*$/i.test(trimmed)
+    || /^#file\s+.+$/i.test(trimmed)
+    || Boolean(prdWorkflowReviewActionLine(line));
+}
+
+function prdWorkflowReviewVerificationContent(lines = []) {
+  const source = Array.isArray(lines) ? [...lines] : [];
+  while (source.length && !String(source[0] || "").trim()) source.shift();
+  while (source.length && !String(source[source.length - 1] || "").trim()) source.pop();
+  if (source.length <= 1) return source;
+  return [source[0], ...prdWorkflowReviewDedentPlannedCode(source.slice(1))];
+}
+
+function prdWorkflowReviewParseVerificationBlock(lines, startIndex) {
+  if (!/^\s*#verification\s*$/i.test(String(lines[startIndex] || ""))) return null;
+  const fields = {
+    entry: [],
+    precondition: [],
+    observation: [],
+    passCriteria: [],
+  };
+  let activeField = "";
+  let boundaryIndex = lines.length;
+  for (let i = startIndex + 1; i < lines.length; i += 1) {
+    const line = String(lines[i] || "");
+    if (/^\s*#verificationend\s*$/i.test(line)) {
+      return {
+        verification: {
+          type: "verification",
+          entry: prdWorkflowReviewVerificationContent(fields.entry),
+          precondition: prdWorkflowReviewVerificationContent(fields.precondition),
+          observation: prdWorkflowReviewVerificationContent(fields.observation),
+          passCriteria: prdWorkflowReviewVerificationContent(fields.passCriteria),
+        },
+        complete: true,
+        endIndex: i,
+      };
+    }
+    if (prdWorkflowReviewVerificationBoundary(line)) {
+      boundaryIndex = i;
+      break;
+    }
+    const field = line.match(/^\s*-\s*(入口|前置条件|观察|通过标准)\s*[:：]\s*(.*)$/);
+    if (field) {
+      activeField = PRD_WORKFLOW_VERIFICATION_FIELDS[field[1]];
+      if (field[2]) fields[activeField].push(field[2]);
+      continue;
+    }
+    if (activeField) fields[activeField].push(line);
+  }
+  return {
+    verification: null,
+    complete: false,
+    endIndex: boundaryIndex - 1,
+    rawLines: lines.slice(startIndex + 1, boundaryIndex),
+  };
+}
+
+function prdWorkflowReviewRenderVerificationBlock(verification) {
+  const fields = [
+    ["入口", verification.entry],
+    ["前置条件", verification.precondition],
+    ["观察", verification.observation],
+    ["通过标准", verification.passCriteria],
+  ];
+  const rows = fields.map(([label, content]) => {
+    const missing = !Array.isArray(content) || !content.some((line) => String(line || "").trim());
+    const value = missing
+      ? '<span class="verification-block__missing">未填写</span>'
+      : prdWorkflowReviewMarkdownLinesToHtml(content);
+    return `<div class="verification-block__field${missing ? " is-missing" : ""}">
+  <dt>${htmlEscapeAttribute(label)}</dt>
+  <dd>${value}</dd>
+</div>`;
+  }).join("");
+  return `<section class="verification-block" data-solution-block="verification">
+  <div class="verification-block__header">
+    <span class="verification-block__badge">验证方案</span>
+    <span>执行与通过标准</span>
+  </div>
+  <dl class="verification-block__fields">${rows}</dl>
+</section>`;
+}
+
+function prdWorkflowReviewRenderIncompleteVerification(rawLines = []) {
+  const body = prdWorkflowReviewMarkdownLinesToHtml(rawLines);
+  return `<section class="verification-block is-incomplete" data-solution-block="verification">
+  <div class="verification-block__header">
+    <span class="verification-block__badge">验证方案</span>
+    <strong>验证块格式不完整</strong>
+  </div>
+  ${body ? `<div class="verification-block__fallback">${body}</div>` : ""}
+</section>`;
+}
+
 function prdWorkflowReviewParseChangeIntent(lines, startIndex) {
   const start = String(lines[startIndex] || "")
     .trim()
@@ -8654,6 +8877,17 @@ function prdWorkflowReviewMarkdownLinesToHtml(lines) {
       flushBlocks();
       continue;
     }
+    if (/^#verification\s*$/i.test(trimmed)) {
+      const parsed = prdWorkflowReviewParseVerificationBlock(lines, i);
+      if (parsed) {
+        flushBlocks();
+        html.push(parsed.complete
+          ? prdWorkflowReviewRenderVerificationBlock(parsed.verification)
+          : prdWorkflowReviewRenderIncompleteVerification(parsed.rawLines));
+        i = parsed.endIndex;
+        continue;
+      }
+    }
     if (/^#change\s+/i.test(trimmed)) {
       const parsed = prdWorkflowReviewParseChangeIntent(lines, i);
       if (parsed) {
@@ -9109,6 +9343,24 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
     .change-intent__proposal-line.is-code { display: grid; grid-template-columns: 2rem minmax(max-content, 1fr); margin: 0 -14px; padding: 0 14px; background: var(--change-code); }
     .change-intent__proposal-mark { color: var(--change-add); font-weight: 900; text-align: center; user-select: none; }
     .change-intent__proposal-text { white-space: pre; }
+    .verification-block { max-width: 100%; margin: 1rem 0 1.2rem; overflow: hidden; border: 1px solid var(--change-border); border-radius: 12px; background: var(--panel-strong); }
+    .verification-block__header { display: flex; align-items: center; gap: 10px; border-bottom: 1px solid var(--change-border); background: var(--change-header); padding: 11px 14px; color: var(--heading); font-size: 13px; font-weight: 900; }
+    .verification-block__badge { flex: 0 0 auto; border: 1px solid currentColor; border-radius: 999px; color: var(--change-move); padding: 4px 9px; font-size: 12px; line-height: 1.3; }
+    .verification-block__fields { margin: 0; }
+    .verification-block__field { display: grid; grid-template-columns: minmax(7rem, 9rem) minmax(0, 1fr); border-top: 1px solid var(--border-soft); }
+    .verification-block__field:first-child { border-top: 0; }
+    .verification-block__field dt { background: var(--change-context); color: var(--body); padding: 11px 14px; font-size: 13px; font-weight: 900; }
+    .verification-block__field dd { min-width: 0; margin: 0; padding: 10px 14px 12px; color: var(--body); }
+    .verification-block__field dd > *:first-child { margin-top: 0; }
+    .verification-block__field dd > *:last-child { margin-bottom: 0; }
+    .verification-block__field.is-missing { opacity: .72; }
+    .verification-block__missing { color: var(--muted); font-size: 13px; font-style: italic; }
+    .verification-block.is-incomplete { border-color: var(--pending-border); }
+    .verification-block.is-incomplete .verification-block__header { border-bottom-color: var(--pending-border); background: var(--pending-bg); color: var(--pending-text); }
+    .verification-block.is-incomplete .verification-block__badge { color: var(--pending-text); }
+    .verification-block__fallback { padding: 10px 14px 12px; }
+    .verification-block__fallback > *:first-child { margin-top: 0; }
+    .verification-block__fallback > *:last-child { margin-bottom: 0; }
     .syntax-comment { color: var(--syntax-comment); font-style: italic; }
     .syntax-keyword { color: var(--syntax-keyword); font-weight: 700; }
     .syntax-literal { color: var(--syntax-literal); font-weight: 650; }
@@ -9154,6 +9406,8 @@ export function prdWorkflowReviewHtml(title, markdown, meta = {}) {
       main { padding: 28px 14px 48px; }
       .change-intent__header { align-items: flex-start; flex-direction: column; }
       .change-intent__locator { width: 100%; }
+      .verification-block__field { grid-template-columns: 1fr; }
+      .verification-block__field dt { border-bottom: 1px solid var(--border-soft); padding-bottom: 8px; }
       .change-intent__source-line, .planned-code__line { grid-template-columns: 3.25rem minmax(max-content, 1fr); }
       header { display: block; }
       .toolbar { justify-content: flex-start; margin-top: 14px; }
@@ -12086,6 +12340,27 @@ export function startUiServer({
       json(res, 200, { token: getSessionTokenFromRequest(req) || "" });
       return;
     }
+    if (req.method === "GET" && url.pathname === "/api/prd-workflows") {
+      if (!authUser?.userId) {
+        json(res, 401, { error: "Unauthorized" });
+        return;
+      }
+      try {
+        const workflows = listPrdWorkflowCollaborationsForUser(userCtx.userId).map((record) => {
+          const stateRoot = path.resolve(getAgentflowUserDataRoot(record.ownerId));
+          const tapdId = String(record.tapdId || "").trim();
+          const project = prdWorkflowReadProjectState(stateRoot, tapdId);
+          const latestClient = prdWorkflowLatestClientSnapshot(stateRoot, stateRoot, tapdId);
+          const legacy = prdWorkflowReadCachedSnapshot(stateRoot, tapdId);
+          const snapshot = project?.snapshot || latestClient || legacy?.snapshot || {};
+          return prdWorkflowDashboardSummary(record, snapshot, userCtx);
+        });
+        json(res, 200, { ok: true, workflows });
+      } catch (error) {
+        json(res, 500, { error: (error && error.message) || String(error) });
+      }
+      return;
+    }
     if (req.method === "GET" && url.pathname === "/api/prd-workflow/share") {
       const tapdId = String(url.searchParams.get("tapdId") || "").trim();
       const shareToken = String(url.searchParams.get("workflowShare") || "").trim();