@guanlin4924/devflow-pi 0.1.17 → 0.1.19

package/README.md

@@ -34,6 +34,8 @@ devflow-pi
 /usage-stats
 ```
 
+`/devflow project-init` 会先读取当前项目已有的 `.planning/PROJECT.md` 与 `.planning/navigation/INDEX.md`：仅回填仍存在于项目根目录内的已登记前后端路径，删除或越界的历史路径会被忽略。随后可选择复用已有边界、复用边界并重建索引，或手动覆盖。初始化模式使用选择器提供“只读规划（默认）”和“写入初始化”；选择后者并确认，只会创建 Devflow 的 `.planning/` 与 `.context/` 初始化产物，不会修改业务源码、依赖或项目配置。
+
 用量统计默认只读取当前项目的隔离会话：`/usage-stats`。需要明确查看历史 OMP 会话时，使用 `/usage-stats omp`，或加筛选条件：`/usage-stats omp --from 2026-08-01 --to 2026-08-10`。历史统计保留真实会话路径，不再把不同项目的长会话文件合并成 `main`；统计只使用 assistant message 的原始 usage，不虚构工具调用成本分摊。
 
 会话继续使用 `devflow-pi --resume`；也可用 `devflow-pi --resume <session-id>` 打开当前项目的指定 Session。OMP 17.2.7 退出时仍会显示上游硬编码的 `omp --resume` 提示，在专项发行版中应替换为这里的 `devflow-pi --resume`，不会去读取官方 OMP 的 Session 目录。

package/package.json

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

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

@@ -16,6 +16,13 @@ export type SessionControlState = {
   label: string;
 };
 
+type ProjectInitializationMode = "plan" | "apply";
+
+type ProjectInitializationRequest = {
+  summary: string;
+  mode: ProjectInitializationMode;
+};
+
 type ActiveExecutionContract = {
   contractId: string;
   feature: string;
@@ -91,6 +98,118 @@ export function planningState(intent: "project-init" | "requirement-draft"): Ses
   };
 }
 
+export type ExistingProjectInitialization = {
+  projectName?: string;
+  frontendPaths: string[];
+  backendPaths: string[];
+  codeIndexStatus?: string;
+  sourcePath: string;
+};
+
+type DocumentedProjectLocations = {
+  frontendPaths: string[];
+  backendPaths: string[];
+};
+
+function markdownTableCells(line: string): string[] | null {
+  if (!line.trim().startsWith("|")) return null;
+  const cells = line.trim().split("|").slice(1, -1).map(cell => cell.trim());
+  return cells.length > 0 ? cells : null;
+}
+
+function documentedProjectPath(raw: string, cwd: string): string | null {
+  const cleaned = raw
+    .replaceAll("`", "")
+    .replaceAll("~", "")
+    .replaceAll("*", "")
+    .replace(/\s*[（(].*$/, "")
+    .trim();
+  if (!cleaned) return null;
+  const absolute = path.resolve(cwd, cleaned);
+  const relative = path.relative(cwd, absolute).replaceAll("\\", "/");
+  if (!relative || relative === ".." || relative.startsWith("../") || path.isAbsolute(relative)) return null;
+  if (!existsSync(absolute)) return null;
+  return relative;
+}
+
+function documentedLocations(markdown: string, cwd: string): DocumentedProjectLocations {
+  const frontendPaths: string[] = [];
+  const backendPaths: string[] = [];
+  const lines = markdown.split(/\r?\n/);
+  for (let index = 0; index < lines.length - 2; index += 1) {
+    const header = markdownTableCells(lines[index]);
+    const divider = markdownTableCells(lines[index + 1]);
+    if (!header || !divider || !divider.every(cell => /^:?-{3,}:?$/.test(cell))) continue;
+    const pathColumn = header.findIndex(cell => /^(?:path|路径)$/i.test(cell));
+    const typeColumn = header.findIndex(cell => /^(?:type|类型)$/i.test(cell));
+    if (pathColumn < 0 || typeColumn < 0) continue;
+    for (let rowIndex = index + 2; rowIndex < lines.length; rowIndex += 1) {
+      const row = markdownTableCells(lines[rowIndex]);
+      if (!row || row.length !== header.length) break;
+      const projectPath = documentedProjectPath(row[pathColumn], cwd);
+      if (!projectPath) continue;
+      const type = row[typeColumn];
+      if (/(?:前端|frontend|\bh5\b|小程序|uniapp)/i.test(type)) frontendPaths.push(projectPath);
+      if (/(?:后端|backend|服务|\bapi\b)/i.test(type)) backendPaths.push(projectPath);
+    }
+  }
+  return {
+    frontendPaths: [...new Set(frontendPaths)],
+    backendPaths: [...new Set(backendPaths)],
+  };
+}
+
+function documentedProjectName(markdown: string): string | undefined {
+  const match = markdown.match(/^\s*-\s*\*\*Name\*\*:\s*(.+?)\s*$/mi);
+  return match?.[1]?.trim() || undefined;
+}
+
+function documentedCodeIndexStatus(markdown: string): string | undefined {
+  const comment = markdown.match(/code_index_status:\s*([^;\-\n]+)/i);
+  if (comment?.[1]?.trim()) return comment[1].trim();
+  const field = markdown.match(/^\s*-\s*\*\*Code Index Status\*\*:\s*([^\n]+)/mi);
+  return field?.[1]?.trim() || undefined;
+}
+
+/**
+ * Reuses only existing, project-local initialization records.  Markdown is
+ * evidence, not authority by itself: every documented path must still exist
+ * beneath the current project root before it can be offered back to the user.
+ */
+export function discoverExistingProjectInitialization(cwd: string): ExistingProjectInitialization | null {
+  const sources = [".planning/PROJECT.md", ".planning/navigation/INDEX.md"];
+  const records: Array<ExistingProjectInitialization> = [];
+  for (const sourcePath of sources) {
+    const absolute = path.join(cwd, sourcePath);
+    if (!existsSync(absolute)) continue;
+    const markdown = readFileSync(absolute, "utf8");
+    const locations = documentedLocations(markdown, cwd);
+    if (locations.frontendPaths.length === 0 && locations.backendPaths.length === 0) continue;
+    records.push({
+      projectName: documentedProjectName(markdown),
+      frontendPaths: locations.frontendPaths,
+      backendPaths: locations.backendPaths,
+      codeIndexStatus: documentedCodeIndexStatus(markdown),
+      sourcePath,
+    });
+  }
+  const preferred = records[0];
+  if (!preferred) return null;
+  const fallback = records.find(record => record !== preferred);
+  const useFallbackFrontend = preferred.frontendPaths.length === 0 && Boolean(fallback?.frontendPaths.length);
+  const useFallbackBackend = preferred.backendPaths.length === 0 && Boolean(fallback?.backendPaths.length);
+  return {
+    projectName: preferred.projectName ?? fallback?.projectName,
+    frontendPaths: preferred.frontendPaths.length > 0 ? preferred.frontendPaths : (fallback?.frontendPaths ?? []),
+    backendPaths: preferred.backendPaths.length > 0 ? preferred.backendPaths : (fallback?.backendPaths ?? []),
+    codeIndexStatus: preferred.codeIndexStatus ?? fallback?.codeIndexStatus,
+    sourcePath: [
+      preferred.sourcePath,
+      ...((useFallbackFrontend || useFallbackBackend) && fallback ? [fallback.sourcePath] : []),
+    ].join(", "),
+  };
+}
+
 export function executingState(label = "当前工作流步骤执行"): SessionControlState {
   return { intent: "workflow-execute", phase: "executing", label };
 }
@@ -726,31 +845,117 @@ export default function devflowCore(pi: ExtensionAPI) {
   }
 
   async function collectProjectInitialization(ctx: {
+    cwd: string;
     ui: {
+      select(title: string, options: Array<{ label: string; description?: string }>): Promise<string | undefined>;
       input(title: string, placeholder?: string): Promise<string | undefined>;
       confirm(title: string, message: string): Promise<boolean>;
       notify(message: string, type?: "info" | "warning" | "error"): void;
     };
-  }): Promise<string | null> {
-    const projectName = await ctx.ui.input("Devflow 项目初始化", "项目名称（留空则使用当前目录）");
-    const frontendPath = await ctx.ui.input("前端边界", "前端目录；没有请填写 none");
-    if (frontendPath === undefined) return null;
-    const backendPath = await ctx.ui.input("后端边界", "后端目录；没有请填写 none");
-    if (backendPath === undefined) return null;
-    const buildIndex = await ctx.ui.input("代码索引", "建立索引？输入 yes 或 no");
-    if (buildIndex === undefined) return null;
+  }): Promise<ProjectInitializationRequest | null> {
+    const existing = discoverExistingProjectInitialization(ctx.cwd);
+    const reuseExisting = "使用已记录的项目结构（推荐）";
+    const rebuildExisting = "使用已记录的项目结构，并重新扫描代码";
+    const manualEntry = "我需要手动指定项目目录";
+
+    let projectName: string | undefined;
+    let frontendPath: string | undefined;
+    let backendPath: string | undefined;
+    let buildIndex: string | undefined;
+    let boundarySource: string | undefined;
+
+    if (existing) {
+      const frontend = existing.frontendPaths.length > 0 ? existing.frontendPaths.join(", ") : "未记录（unknown）";
+      const backend = existing.backendPaths.length > 0 ? existing.backendPaths.join(", ") : "未记录（unknown）";
+      const selected = await ctx.ui.select("检测到已有项目记录：这次初始化怎么处理？", [
+        {
+          label: reuseExisting,
+          description: `直接复用下面已核验、仍存在的目录，不重新扫描代码。\n前端：${frontend}\n后端：${backend}\n记录来源：${existing.sourcePath}${existing.codeIndexStatus ? `；索引状态：${existing.codeIndexStatus}` : ""}`,
+        },
+        {
+          label: rebuildExisting,
+          description: `沿用已登记目录，但重新扫描代码并更新索引。\n前端：${frontend}\n后端：${backend}`,
+        },
+        {
+          label: manualEntry,
+          description: "不采用上面的记录。我会依次询问项目名、前端目录和后端目录；目录均相对当前项目根目录。",
+        },
+      ]);
+      if (!selected) return null;
+      if (selected === reuseExisting || selected === rebuildExisting) {
+        projectName = existing.projectName;
+        frontendPath = existing.frontendPaths.join(", ") || "unknown";
+        backendPath = existing.backendPaths.join(", ") || "unknown";
+        buildIndex = selected === reuseExisting
+          ? `复用已有索引${existing.codeIndexStatus ? `（${existing.codeIndexStatus}）` : ""}`
+          : "yes";
+        boundarySource = `${existing.sourcePath}（已校验目录仍存在）`;
+      }
+    }
+
+    if (!frontendPath || !backendPath || !buildIndex) {
+      projectName = await ctx.ui.input(
+        "项目显示名称（可留空）",
+        "用于 Devflow 文档标题；留空时使用当前目录名。例如：商城运营平台",
+      );
+      if (projectName === undefined) return null;
+      frontendPath = await ctx.ui.input(
+        "前端代码目录（相对当前项目根目录）",
+        "可填写多个目录，用英文逗号分隔。例：apps/admin, apps/h5；不确定请填 unknown",
+      );
+      if (frontendPath === undefined) return null;
+      backendPath = await ctx.ui.input(
+        "后端代码目录（相对当前项目根目录）",
+        "例：services/api 或 server；项目没有后端请填 none；不确定请填 unknown",
+      );
+      if (backendPath === undefined) return null;
+      const fullIndex = "建立完整代码索引（推荐）";
+      const skipIndex = "暂不建立代码索引";
+      const selectedIndex = await ctx.ui.select("是否扫描代码并建立索引？", [
+        {
+          label: fullIndex,
+          description: "扫描已确认的代码目录，建立调用关系和符号索引；后续需求与架构评估可直接复用。",
+        },
+        {
+          label: skipIndex,
+          description: "只建立项目说明与规则入口；后续需要源码级分析时再补建索引。",
+        },
+      ]);
+      if (!selectedIndex) return null;
+      buildIndex = selectedIndex === fullIndex ? "yes" : "no";
+    }
+    const planMode = "只读规划（不写任何项目文件）";
+    const applyMode = "写入初始化";
+    const selectedMode = await ctx.ui.select("确认这次初始化是否写入项目文件？", [
+      {
+        label: planMode,
+        description: "只读取项目和已有初始化记录，输出规划与待确认项；不写入任何项目文件。",
+      },
+      {
+        label: applyMode,
+        description: "确认范围后创建或更新 Devflow 初始化产物；不修改业务源码、依赖或项目配置。",
+      },
+    ]);
+    if (!selectedMode) return null;
+    const mode: ProjectInitializationMode = selectedMode === applyMode ? "apply" : "plan";
+    const modeSummary = mode === "apply" ? "写入初始化" : "只读规划";
     const summary = [
       `项目名：${projectName?.trim() || "当前目录"}`,
       `前端：${frontendPath.trim() || "未提供"}`,
       `后端：${backendPath.trim() || "未提供"}`,
       `建立代码索引：${buildIndex.trim() || "未提供"}`,
+      ...(boundarySource ? [`边界来源：${boundarySource}`] : []),
+      `初始化方式：${modeSummary}`,
     ].join("\n");
-    const confirmed = await ctx.ui.confirm("确认项目初始化范围", `${summary}\n\n确认后只进入只读规划，不会创建工作流或写入项目文件。`);
+    const consequence = mode === "apply"
+      ? "确认后会创建 Devflow 的 .planning/ 与 .context/ 初始化产物；不会修改业务源码、依赖或项目配置。"
+      : "确认后只进入只读规划，不会创建工作流或写入项目文件。";
+    const confirmed = await ctx.ui.confirm("确认项目初始化范围", `${summary}\n\n${consequence}`);
     if (!confirmed) {
       ctx.ui.notify("项目初始化已取消；未写入任何文件。", "info");
       return null;
     }
-    return summary;
+    return { summary, mode };
   }
 
   async function runRuby(cwd: string, relativeScript: string, args: string[]) {
@@ -952,7 +1157,7 @@ export default function devflowCore(pi: ExtensionAPI) {
   }
 
   let activeWorkflowTurn = false;
-  let pendingProjectInitialization: string | undefined;
+  let pendingProjectInitialization: ProjectInitializationRequest | undefined;
 
   async function triggerWorkflow(snapshot: Record<string, unknown>, source: "start" | "approval", requirementDraft?: string) {
     activeWorkflowTurn = true;
@@ -1013,7 +1218,7 @@ export default function devflowCore(pi: ExtensionAPI) {
         }
         setControlState(ctx, executingState("执行已批准的项目初始化"));
         activeWorkflowTurn = true;
-        return { text: projectInitializationDirective(pendingProjectInitialization), handled: false };
+        return { text: projectInitializationDirective(pendingProjectInitialization.summary), handled: false };
       }
       if (controlAction === "reject") {
         ctx.ui.notify("已保留初始化规划，未创建任何项目控制文件。请直接说明需要调整的初始化范围。", "info");
@@ -1070,9 +1275,14 @@ export default function devflowCore(pi: ExtensionAPI) {
       return { handled: true };
     }
     if (intent === "project-init") {
-      const summary = await collectProjectInitialization(ctx);
-      if (!summary) return { handled: true };
-      pendingProjectInitialization = summary;
+      const initialization = await collectProjectInitialization(ctx);
+      if (!initialization) return { handled: true };
+      pendingProjectInitialization = initialization;
+      if (initialization.mode === "apply") {
+        setControlState(ctx, executingState("执行已确认的项目初始化"));
+        activeWorkflowTurn = true;
+        return { text: projectInitializationDirective(initialization.summary), handled: false };
+      }
       const state = planningState("project-init");
       setControlState(ctx, state);
       return {
@@ -1081,7 +1291,7 @@ export default function devflowCore(pi: ExtensionAPI) {
           "用户已确认项目初始化的输入。你现在是 Planner，只允许只读分析和派发 project-scout / requirements-auditor / contract-auditor。",
           "不得创建 .planning 文件、不得调用状态迁移、不得执行实现。",
           "先输出：已知事实、待验证点、最少侦察任务和必须由用户决定的问题。没有证据时写 unknown。",
-          summary,
+          initialization.summary,
           "</devflow-planner-directive>",
         ].join("\n"),
       };
@@ -2026,9 +2236,15 @@ export default function devflowCore(pi: ExtensionAPI) {
         return;
       }
       if (trimmed === "project-init") {
-        const summary = await collectProjectInitialization(ctx);
-        if (!summary) return;
-        pendingProjectInitialization = summary;
+        const initialization = await collectProjectInitialization(ctx);
+        if (!initialization) return;
+        pendingProjectInitialization = initialization;
+        if (initialization.mode === "apply") {
+          setControlState(ctx, executingState("执行已确认的项目初始化"));
+          activeWorkflowTurn = true;
+          await pi.sendUserMessage(projectInitializationDirective(initialization.summary));
+          return;
+        }
         setControlState(ctx, planningState("project-init"));
         await pi.sendUserMessage(
           [
@@ -2036,7 +2252,7 @@ export default function devflowCore(pi: ExtensionAPI) {
             "用户已确认项目初始化的输入。你现在是 Planner，只允许只读分析和派发 project-scout / requirements-auditor / contract-auditor。",
             "不得创建 .planning 文件、不得调用状态迁移、不得执行实现。",
             "先输出：已知事实、待验证点、最少侦察任务和必须由用户决定的问题。没有证据时写 unknown。",
-            summary,
+            initialization.summary,
             "</devflow-planner-directive>",
           ].join("\n"),
         );