@guanlin4924/devflow-pi 0.1.18 → 0.1.19

package/README.md

@@ -34,7 +34,7 @@ devflow-pi
 /usage-stats
 ```
 
-`/devflow project-init` 会在边界确认时提供两种模式：`plan`（默认，只读规划）和 `apply`（写入初始化）。选择 `apply` 并确认后，只会创建 Devflow 的 `.planning/` 与 `.context/` 初始化产物，不会修改业务源码、依赖或项目配置。
+`/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，不虚构工具调用成本分摊。
 

package/package.json

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

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

@@ -98,11 +98,116 @@ export function planningState(intent: "project-init" | "requirement-draft"): Ses
   };
 }
 
-function parseProjectInitializationMode(value: string): ProjectInitializationMode | null {
-  const normalized = value.trim().toLowerCase();
-  if (["", "plan", "readonly", "read-only", "只读", "规划"].includes(normalized)) return "plan";
-  if (["apply", "write", "写入", "执行"].includes(normalized)) return "apply";
-  return null;
+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 {
@@ -740,32 +845,106 @@ 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<ProjectInitializationRequest | 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;
-    const initializationMode = await ctx.ui.input("初始化方式", "输入 plan（只读规划，默认）或 apply（写入初始化）");
-    if (initializationMode === undefined) return null;
-    const mode = parseProjectInitializationMode(initializationMode);
-    if (!mode) {
-      ctx.ui.notify("初始化方式只能是 plan（只读规划）或 apply（写入初始化）；未写入任何文件。", "error");
-      return 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 consequence = mode === "apply"