@guanlin4924/devflow-pi 0.1.50 → 0.1.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guanlin4924/devflow-pi",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "type": "module",
   "description": "Devflow 专项研发 Pi，基于固定版本 OMP Runtime 组装研发状态机、代码智能、设计、实现与质量门禁。",
   "license": "UNLICENSED",

package/plugins/devflow-core/extensions/devflow-core.ts

@@ -4,6 +4,7 @@ import { appendFile, mkdir, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { Box, Text } from "@oh-my-pi/pi-tui";
 import {
   TASK_SUBAGENT_LIFECYCLE_CHANNEL,
   type SubagentLifecyclePayload,
@@ -27,6 +28,96 @@ type ProjectInitializationRequest = {
   mode: ProjectInitializationMode;
 };
 
+const workflowStepNames: Record<string, string> = {
+  "requirement-triage": "需求梳理",
+  "requirement-wayfinder": "需求路径规划",
+  "domain-modeling": "领域建模",
+  "requirement-feasibility-review": "需求可行性审查",
+  "requirement-baseline": "需求基线确认",
+  "wireframe-proposal": "原型方案",
+  "wireframe-validate": "原型校验",
+  "wireframe-render": "原型预览生成",
+  "wireframe-review": "原型审查",
+  "api-contract": "接口契约",
+  "architecture-feasibility": "架构可行性评估",
+  "ui-spec": "界面规格",
+  "feature-breakdown": "功能拆分",
+  "frontend-tech-spec": "前端技术方案",
+  "backend-tech-spec": "后端技术方案",
+  "api-call-guide": "接口调用说明",
+  "api-supplement": "接口补充设计",
+  "integration-verify": "集成验证",
+  "change-plan": "变更计划",
+  "acceptance-test-design": "验收测试设计",
+  "phase-structure": "阶段结构确认",
+  "execute": "实现执行",
+  "code-index-refresh": "代码索引刷新",
+  "code-review": "代码审查",
+  "generate-mainflow-cases": "主流程用例生成",
+  "run-acceptance-tests": "冻结验收测试执行",
+  "release-closeout": "发布收尾与里程碑归档",
+  "dual-track-design": "前后端并行设计",
+  "acceptance-failed-remediation": "验收失败修复",
+  "diagnose": "验收失败诊断",
+  "execute-fix": "修复执行",
+};
+
+const workflowStatusNames: Record<string, string> = {
+  completed: "已完成",
+  current: "进行中",
+  pending: "未开始",
+  waiting_review: "等待审查",
+  blocked: "已阻塞",
+  failed: "执行失败",
+  cancelled: "已取消",
+  unknown: "未知",
+};
+
+const workflowActionNames: Record<string, string> = {
+  run_next_step: "执行下一步骤",
+  run_parallel_window: "执行并行步骤",
+  route_failure_branch: "进入失败处理分支",
+  await_user_confirmation: "等待人工确认",
+  recover_artifact_registry: "恢复工件登记",
+  workflow_complete: "功能交付已完成",
+  workflow_cancelled: "功能交付已取消",
+  blocked: "处理阻塞项",
+};
+
+function workflowSteps(snapshot: Record<string, unknown>): Array<{ id: string; label: string; status: string }> {
+  if (!Array.isArray(snapshot.workflow_steps)) return [];
+  return snapshot.workflow_steps.flatMap(step => {
+    if (!step || typeof step !== "object") return [];
+    const record = step as Record<string, unknown>;
+    const id = typeof record.id === "string" ? record.id : "";
+    if (!id) return [];
+    return [{
+      id,
+      label: typeof record.label === "string" && record.label ? record.label : id,
+      status: typeof record.status === "string" ? record.status : "unknown",
+    }];
+  });
+}
+
+function workflowStepName(id: string | undefined, fallback?: string): string {
+  if (id && workflowStepNames[id]) return workflowStepNames[id];
+  return fallback || id || "未开始";
+}
+
+function workflowStatusName(status: unknown): string {
+  return typeof status === "string" ? workflowStatusNames[status] ?? status : "未知";
+}
+
+function workflowActionName(action: unknown): string {
+  return typeof action === "string" ? workflowActionNames[action] ?? action : "正在确认";
+}
+
+function workflowPhaseName(phase: unknown): string {
+  if (typeof phase !== "string" || !phase) return "未开始";
+  if (phase.startsWith("feature-")) return "功能交付";
+  return phase;
+}
+
 type ActiveExecutionContract = {
   contractId: string;
   feature: string;
@@ -897,20 +988,21 @@ function projectInitializationDirective(summary: string): string {
 }
 
 function explainWorkflowSnapshot(snapshot: Record<string, unknown> | null): string {
-  if (!snapshot) return "Devflow 当前没有可解释的工作流状态。可使用 /devflow start <feature> 创建新 Feature。";
+  if (!snapshot) return "Devflow 当前没有可解释的工作流状态。可使用 /devflow start <功能名> 创建新功能。";
   const step = compactStep(snapshot.next_step) ?? compactStep(snapshot.current_step);
   const lines = [
-    `Feature：${String(snapshot.current_feature ?? "未开始")}`,
-    `状态：${String(snapshot.status ?? "unknown")}`,
-    `动作：${String(snapshot.action ?? "unknown")}`,
-    `Revision：${String(snapshot.revision ?? "unknown")}`,
+    `功能：${String(snapshot.current_feature ?? "未开始")}`,
+    `阶段：${workflowPhaseName(snapshot.current_phase)}`,
+    `状态：${workflowStatusName(snapshot.status)}`,
+    `动作：${workflowActionName(snapshot.action)}`,
+    `版本：${String(snapshot.revision ?? "未知")}`,
   ];
-  if (step?.id) lines.push(`当前/下一步骤：${String(step.id)}${step.label ? `（${String(step.label)}）` : ""}`);
-  if (snapshot.checkpoint) lines.push(`Checkpoint：${String(snapshot.checkpoint)}`);
+  if (step?.id) lines.push(`当前/下一节点：${workflowStepName(step.id, step.label)}`);
+  if (snapshot.checkpoint) lines.push(`检查点：${String(snapshot.checkpoint)}`);
   if (snapshot.action === "workflow_complete") {
-    lines.push("结论：上一 Feature 已完成；可以使用 /devflow start <新功能名> 创建下一 Feature。");
+    lines.push("结论：上一功能已完成；可以使用 /devflow start <功能名> 创建下一功能。");
   } else {
-    lines.push("结论：这是只读解释；未执行任何状态迁移或文件写入。");
+    lines.push("结论：这是只读说明；未执行任何状态迁移或文件写入。");
   }
   return lines.join("\n");
 }
@@ -1129,33 +1221,13 @@ export default function devflowCore(pi: ExtensionAPI) {
 
   type ProjectControlUi = {
     setStatus(key: string, text: string | undefined): void;
-    setWidget?(key: string, content: string[] | undefined, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
+    // OMP widgets accept either plain lines or a component factory. Keep this
+    // interface structural because command contexts are supplied by OMP.
+    setWidget?(key: string, content: unknown, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
   };
 
   let projectControlRefreshRevision = 0;
 
-  function workflowSteps(snapshot: Record<string, unknown>): Array<{ id: string; label: string; status: string }> {
-    if (!Array.isArray(snapshot.workflow_steps)) return [];
-    return snapshot.workflow_steps.flatMap(step => {
-      if (!step || typeof step !== "object") return [];
-      const record = step as Record<string, unknown>;
-      const id = typeof record.id === "string" ? record.id : "";
-      if (!id) return [];
-      return [{
-        id,
-        label: typeof record.label === "string" && record.label ? record.label : id,
-        status: typeof record.status === "string" ? record.status : "unknown",
-      }];
-    });
-  }
-
-  function workflowStepIcon(status: string): string {
-    if (status === "completed") return "✓";
-    if (status === "current") return "●";
-    if (status === "waiting_review") return "◆";
-    if (status === "blocked") return "!";
-    return "○";
-  }
 
   function projectActionLabel(snapshot: Record<string, unknown>): string {
     switch (snapshot.action) {
@@ -1166,11 +1238,11 @@ export default function devflowCore(pi: ExtensionAPI) {
       case "await_user_confirmation":
         return "审查产物后批准推进";
       case "recover_artifact_registry":
-        return "可执行安全恢复（仅 registry）";
+        return "可执行安全恢复（仅工件登记）";
       case "workflow_complete":
-        return "当前 Feature 已完成";
+        return "当前功能已完成";
       case "workflow_cancelled":
-        return "当前 Feature 已取消";
+        return "当前功能已取消";
       case "blocked":
         return "先处理阻塞证据";
       default:
@@ -1184,59 +1256,78 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (state.phase === "blocked") return `已阻塞：${state.label}`;
     if (snapshot.action === "await_user_confirmation") return "等待人工审查";
     if (snapshot.action === "blocked") return "已阻塞";
-    return "当前会话未运行 Agent";
+    return "当前会话未运行智能体";
   }
 
   function projectControlPanel(snapshot: Record<string, unknown> | null, state: SessionControlState): string[] {
     if (!snapshot) {
-      return ["Devflow 当前 Feature 交付链路", "尚未读取到有效控制面状态。"];
+      return ["Devflow 当前功能交付", "── 项目状态 ──", "尚未读取到有效控制面状态。"];
     }
     const steps = workflowSteps(snapshot);
     const completedCount = steps.filter(step => step.status === "completed").length;
-    const current = compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
+    const selectedStep = compactStep(snapshot.current_step) ?? compactStep(snapshot.next_step);
+    const currentStep = selectedStep
+      ? workflowStepName(selectedStep.id, selectedStep.label)
+      : "未开始";
+    const nextStep = steps.find(step => step.status !== "completed" && step.id !== selectedStep?.id)
+      ?? steps.find(step => step.status !== "completed");
     const recovery = snapshot.recovery_plan && typeof snapshot.recovery_plan === "object"
       ? snapshot.recovery_plan as Record<string, unknown>
       : undefined;
     const recoveryLabel = recovery?.classification === "safe_repairable"
-      ? "已提供安全恢复方案（不推进步骤）"
+      ? "可执行安全恢复（不会推进节点）"
       : snapshot.action === "blocked"
-        ? "没有可自动执行的重置方案；请先查看阻塞证据。"
-        : "当前无需恢复或重置。";
-    const chain = steps.length > 0
-      ? steps.map(step => `${workflowStepIcon(step.status)} ${step.label}`).join(" → ")
-      : "尚无可展示的已知工作流步骤。";
+        ? "暂无自动重置方案，请先查看阻塞证据"
+        : "当前无需恢复或重置";
     return [
-      `Devflow 当前 Feature 交付链路 · ${String(snapshot.current_feature ?? "未开始")}`,
-      `阶段：${String(snapshot.current_phase ?? "unknown")}    Revision：${String(snapshot.revision ?? "unknown")}`,
-      `链路：${chain}`,
-      `进度：已完成 ${completedCount} / 当前已知 ${steps.length} 步`,
-      `当前节点：${current?.label ? String(current.label) : String(current?.id ?? "未开始")}`,
-      `工作流状态：${String(snapshot.status ?? "unknown")}    执行状态：${projectExecutionLabel(state, snapshot)}`,
-      `当前可执行操作：${projectActionLabel(snapshot)}`,
-      `恢复与重置：${recoveryLabel}`,
+      `Devflow 当前功能交付 · ${String(snapshot.current_feature ?? "未开始")}`,
+      `阶段：${workflowPhaseName(snapshot.current_phase)}    版本：${String(snapshot.revision ?? "未知")}`,
+      "── 交付链路 ──",
+      `进度：已完成 ${completedCount} / 当前已知 ${steps.length} 步    工作流：${workflowStatusName(snapshot.status)}`,
+      `当前：${currentStep}${nextStep ? `    后续：${workflowStepName(nextStep.id, nextStep.label)}` : ""}`,
+      "── 当前节点 ──",
+      `节点状态：${workflowStatusName(selectedStep?.status)}    执行状态：${projectExecutionLabel(state, snapshot)}`,
+      `节点动作：${workflowActionName(snapshot.action)}`,
+      "── 下一步执行 ──",
+      `可执行操作：${projectActionLabel(snapshot)}`,
+      "── 恢复与重置 ──",
+      `处理建议：${recoveryLabel}`,
     ];
   }
 
+  function projectControlWidget(lines: string[]) {
+    return (_tui: unknown, theme: { fg(color: "accent" | "muted" | "dim", text: string): string; bold(text: string): string }) => {
+      const panel = new Box(1, 0, undefined, {
+        chars: { topLeft: "╭", topRight: "╮", bottomLeft: "╰", bottomRight: "╯", horizontal: "─", vertical: "│" },
+        color: text => theme.fg("dim", text),
+      });
+      const content = lines.map((line, index) => {
+        if (index === 0) return theme.bold(theme.fg("accent", line));
+        if (line.startsWith("──")) return theme.fg("accent", line);
+        return theme.fg("muted", line);
+      }).join("\n");
+      panel.addChild(new Text(content, 0, 0));
+      return panel;
+    };
+  }
+
   function refreshProjectControlPanel(ctx: { cwd: string; ui: ProjectControlUi }): void {
     const request = ++projectControlRefreshRevision;
     void inspectWorkflow(ctx.cwd).then(({ result, snapshot }) => {
       if (request !== projectControlRefreshRevision) return;
       const content = result.ok
         ? projectControlPanel(snapshot, controlState)
-        : ["Devflow 当前 Feature 交付链路", "状态读取失败；未执行任何恢复或状态迁移。"];
-      ctx.ui.setWidget?.("devflow-project-control", content, { placement: "aboveEditor" });
+        : ["Devflow 当前功能交付", "── 项目状态 ──", "状态读取失败；未执行任何恢复或状态迁移。"];
+      ctx.ui.setWidget?.("devflow-project-control", projectControlWidget(content), { placement: "aboveEditor" });
     }).catch(() => {
       if (request !== projectControlRefreshRevision) return;
-      ctx.ui.setWidget?.("devflow-project-control", ["Devflow 当前 Feature 交付链路", "状态读取失败；未执行任何恢复或状态迁移。"], { placement: "aboveEditor" });
+      ctx.ui.setWidget?.("devflow-project-control", projectControlWidget(["Devflow 当前功能交付", "── 项目状态 ──", "状态读取失败；未执行任何恢复或状态迁移。"]), { placement: "aboveEditor" });
     });
   }
 
   function setControlState(ctx: {
     cwd: string;
-    ui: {
-      setStatus(key: string, text: string | undefined): void;
-      setWidget?(key: string, content: string[] | undefined, options?: { placement?: "aboveEditor" | "belowEditor" }): void;
-    };
+    ui: ProjectControlUi;
   }, state: SessionControlState) {
     controlState = state;
     ctx.ui.setStatus("devflow-control", statusText(state));
@@ -1914,27 +2005,27 @@ export default function devflowCore(pi: ExtensionAPI) {
     const feature = typeof snapshot?.current_feature === "string" ? snapshot.current_feature : undefined;
     const status = typeof snapshot?.status === "string" ? snapshot.status : undefined;
     if (!inspected.result.ok || revision === undefined || !feature || !status || ["completed", "cancelled", "failed"].includes(status)) {
-      ctx.ui.notify("当前没有可取消的进行中 Feature。", "error");
+      ctx.ui.notify("当前没有可取消的进行中功能。", "error");
       return;
     }
-    const reason = await ctx.ui.input("取消当前 Feature", "请输入取消原因");
+    const reason = await ctx.ui.input("取消当前功能", "请输入取消原因");
     if (!reason?.trim()) return;
     const confirmed = await ctx.ui.confirm(
-      "确认取消当前 Feature",
-      `Feature：${feature}\n原因：${reason.trim()}\n\n将结束当前 Feature、释放项目占用并保留现有工件；未完成步骤不会被标记为完成。继续吗？`,
+      "确认取消当前功能",
+      `功能：${feature}\n原因：${reason.trim()}\n\n将结束当前功能、释放项目占用并保留现有工件；未完成步骤不会被标记为完成。继续吗？`,
     );
     if (!confirmed) return;
     const result = await runRuby(ctx.cwd, "workflow-orchestrator/scripts/advance_state.rb", [
       "--write", "--json", "--cancel", "--cancel-reason", reason.trim(), "--expected-revision", String(revision),
     ]);
     if (!controlPlaneSucceeded(result)) {
-      ctx.ui.notify(`取消当前 Feature 失败：${result.stderr || result.stdout}`, "error");
+      ctx.ui.notify(`取消当前功能失败：${result.stderr || result.stdout}`, "error");
       return;
     }
     activeContract = undefined;
     contractAgentCalls = 0;
     setControlState(ctx, initialControlState());
-    ctx.ui.notify(`Feature“${feature}”已取消；现有工件已保留。`, "info");
+    ctx.ui.notify(`功能“${feature}”已取消；现有工件已保留。`, "info");
   }
 
   async function openProjectControlPanel(ctx: ProjectControlCommandContext): Promise<void> {
@@ -1951,10 +2042,10 @@ export default function devflowCore(pi: ExtensionAPI) {
       if (["run_next_step", "run_parallel_window", "route_failure_branch"].includes(String(snapshot.action))) options.push("启动当前可执行步骤");
       if (snapshot.action === "await_user_confirmation") options.push("审查并批准推进…");
       if (hasSafeRecoveryPlan(snapshot)) options.push("执行安全恢复…");
-      if (typeof snapshot.current_feature === "string" && !["completed", "cancelled", "failed"].includes(String(snapshot.status))) options.push("取消当前 Feature…");
+      if (typeof snapshot.current_feature === "string" && !["completed", "cancelled", "failed"].includes(String(snapshot.status))) options.push("取消当前功能…");
       options.push("关闭");
 
-      const selected = await ctx.ui.select(projectControlPanel(snapshot, controlState).join("\n"), options);
+      const selected = await ctx.ui.select("项目控制操作", options);
       if (!selected || selected === "关闭") return;
       if (selected === "刷新状态") continue;
       if (selected === "查看状态说明") {
@@ -1978,7 +2069,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         await executeSafeRecoveryFromPanel(ctx);
         return;
       }
-      if (selected === "取消当前 Feature…") {
+      if (selected === "取消当前功能…") {
         await cancelFeatureFromPanel(ctx);
         return;
       }

package/src/constants.ts

@@ -1,5 +1,5 @@
 export const PRODUCT_NAME = "Devflow Pi";
-export const PRODUCT_VERSION = "0.1.50";
+export const PRODUCT_VERSION = "0.1.51";
 export const PROJECT_SCHEMA_VERSION = 1;
 export const OMP_RUNTIME_VERSION = "17.2.7";