@guanlin4924/devflow-pi 0.1.62 → 0.1.64

package/README.md

@@ -75,34 +75,7 @@ skills:
     # 其余四个插件目录同理
 ```
 
-## 私有源码兼容模式
-
-`install.sh --apply` 只用于已经获得内部源码访问权限的开发环境。本文档不提供私有仓库地址；在内部工作副本中执行：
-
-```bash
-bash .skills/install.sh --apply
-```
-
-它会执行 postflight；已有但不兼容的 `.omp/config.yml` 会使安装失败，不会以警告方式假装安装完整。
-
-安装器只生成以下 OMP 原生资源：
-
-```text
-.omp/config.yml
-.omp/AGENTS.md
-.omp/extensions/devflow-*.ts
-.omp/agents/*.md
-.omp/hook-config.json
-.agent-gates/index-first.json
-```
-
-已有且兼容的 `.omp/config.yml` 会保留。源码兼容模式下，已有配置缺少 Devflow skill 来源、model overrides 或工具策略时，先审查差异，再显式运行：
-
-```bash
-bash .skills/install.sh --apply --force-config
-```
-
-启动 OMP 后：
+启动已发布的 Devflow Pi 后：
 
 ```text
 /devflow doctor
@@ -174,11 +147,3 @@ npm install -g @guanlin4924/devflow-pi@latest
 - 索引是加速器，不是真相源；过期时回退到 LSP、搜索、源码和测试。
 - 人工 checkpoint 不得在 headless 模式静默通过。
 - semantic correctness 不能靠 prompt 保证，必须由契约、确定性校验、独立审查和可复现测试共同约束。
-
-源码兼容模式刷新：
-
-```bash
-bash .skills/install.sh --refresh
-```
-
-刷新完成后重启 OMP 并再次运行 `/devflow doctor`。如果模板新增了强制配置而项目配置被保留，安装器会拒绝完成；审查后使用 `--force-config` 更新。

package/package.json

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

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

@@ -5,10 +5,17 @@ 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 { Database } from "bun:sqlite";
 import {
   TASK_SUBAGENT_LIFECYCLE_CHANNEL,
   type SubagentLifecyclePayload,
 } from "@oh-my-pi/pi-coding-agent/task";
+import { InitializationStore, FACT_KINDS } from "../../../src/initialization-store.ts";
+import { loadProjectContext } from "../../../src/project-context.ts";
+import { runProjectInitialization } from "../../../src/project-initializer.ts";
+import { projectControlDatabasePath } from "../../../src/paths.ts";
+import { generateProjectDocuments } from "../../../src/project-documents.ts";
+import { exportInitializationSnapshot, importLegacyInitialization, switchInitializationAuthority } from "../../../src/project-migration.ts";
 
 
 export type DevflowIntent = "idle" | "explain-state" | "project-init" | "requirement-draft" | "workflow-execute";
@@ -175,6 +182,7 @@ const READ_ONLY_TOOLS = new Set([
   "devflow_acceptance_tests",
   "devflow_usage_stats",
   "usage_stats",
+  "devflow_project_context",
 ]);
 const REQUIREMENT_DRAFT_TOOLS = new Set([...READ_ONLY_TOOLS, "ask"]);
 // A Todo update changes only the client-visible task list, never the project
@@ -299,7 +307,43 @@ function documentedCodeIndexStatus(markdown: string): string | undefined {
  * 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 {
+export function discoverExistingProjectInitialization(cwd: string, options: { allowLegacyImport?: boolean } = {}): ExistingProjectInitialization | null {
+  const projectManifest = path.join(cwd, ".devflow", "project.json");
+  if (existsSync(projectManifest)) {
+    try {
+      const manifest = JSON.parse(readFileSync(projectManifest, "utf8")) as { projectId?: string };
+      if (manifest.projectId) {
+        const databasePath = projectControlDatabasePath(manifest.projectId);
+        if (existsSync(databasePath)) {
+          const database = new Database(databasePath, { readonly: true });
+          try {
+            const current = database.query(`SELECT c.config_json AS config, s.completeness
+              FROM workspaces w
+              JOIN authority_state a ON a.project_id=w.project_id AND a.authority='database'
+              JOIN current_context p ON p.workspace_id=w.id
+              JOIN scan_configs c ON c.id=p.config_id
+              JOIN context_snapshots s ON s.id=p.snapshot_id
+              WHERE w.project_id=? AND w.location=? ORDER BY p.revision DESC LIMIT 1`
+            ).get(manifest.projectId, realpathSync(cwd)) as { config: string; completeness: string } | null;
+            if (current) {
+              const config = JSON.parse(current.config) as { repositories?: Array<{ relativePath?: string; role?: string }> };
+              const repositories = config.repositories ?? [];
+              const existing = (repository: { relativePath?: string }) => repository.relativePath && documentedProjectPath(repository.relativePath, cwd);
+              return {
+                frontendPaths: repositories.filter(item => item.role === "frontend").map(existing).filter((item): item is string => Boolean(item)),
+                backendPaths: repositories.filter(item => item.role === "backend").map(existing).filter((item): item is string => Boolean(item)),
+                codeIndexStatus: current.completeness,
+                sourcePath: databasePath,
+              };
+            }
+          } finally { database.close(); }
+        }
+      }
+    } catch {
+      // Legacy Markdown below remains import evidence when the database is not usable.
+    }
+  }
+  if (!options.allowLegacyImport) return null;
   const sources = [".planning/PROJECT.md", ".planning/navigation/INDEX.md"];
   const records: Array<ExistingProjectInitialization> = [];
   for (const sourcePath of sources) {
@@ -1195,6 +1239,106 @@ export function stepScopedMutationBlockReason(
 
 export default function devflowCore(pi: ExtensionAPI) {
   const { z } = pi.zod;
+  pi.registerTool({
+    name: "devflow_project_context",
+    label: "Devflow Project Context",
+    description: "Build or query the database-backed, versioned project initialization context. Scan is local and static; it never executes discovered commands.",
+    parameters: z.object({
+      action: z.enum(["scan", "query", "config", "workspaces", "rebind-workspace", "diff", "run-status", "cancel", "recover", "generate-docs", "import-legacy", "export", "authority", "switch-authority", "backup", "restore"]),
+      runId: z.string().optional(),
+      snapshotId: z.string().optional(),
+      fromSnapshotId: z.string().optional(),
+      toSnapshotId: z.string().optional(),
+      kind: z.enum(FACT_KINDS).optional(),
+      repository: z.string().optional(),
+      after: z.string().optional(),
+      limit: z.number().int().min(1).max(500).default(100),
+      requestId: z.string().optional(),
+      mode: z.enum(["full", "fast"]).optional(),
+      repositories: z.array(z.object({
+        name: z.string().min(1),
+        path: z.string().min(1),
+        role: z.enum(["frontend", "backend", "shared", "other"]),
+      })).optional(),
+      requiredKinds: z.array(z.enum(FACT_KINDS)).optional(),
+      documentMode: z.enum(["template", "none"]).optional(),
+      sources: z.array(z.string()).optional(),
+      targetPath: z.string().optional(),
+      authority: z.enum(["legacy", "shadow", "database"]).optional(),
+      expectedRevision: z.number().int().min(0).optional(),
+      compatibilityExport: z.string().optional(),
+      workspaceId: z.string().optional(),
+    }),
+    approval: args => (["query", "config", "workspaces", "diff", "run-status", "authority"].includes(args.action) ? "read" : "exec"),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      try {
+        const project = await loadProjectContext(ctx.cwd);
+        let value: unknown;
+        if (params.action === "scan") {
+          const config = params.repositories?.length ? {
+            mode: params.mode ?? "full" as const,
+            repositories: params.repositories.map(item => ({ name: item.name, relativePath: item.path, role: item.role })),
+            requiredKinds: params.requiredKinds,
+            adapterVersions: { static: "1" },
+          } : undefined;
+          value = await runProjectInitialization(project, { requestId: params.requestId, config, documentMode: params.documentMode ?? "template" });
+        } else if (params.action === "generate-docs") {
+          if (!params.snapshotId) throw new Error("snapshotId is required for generate-docs");
+          value = await generateProjectDocuments(project, params.snapshotId, { mode: "template" });
+        } else if (params.action === "import-legacy") {
+          value = await importLegacyInitialization(project, params.sources ?? [], params.requestId);
+        } else if (params.action === "export") {
+          if (!params.snapshotId || !params.targetPath) throw new Error("snapshotId and targetPath are required for export");
+          value = await exportInitializationSnapshot(project, params.snapshotId, params.targetPath);
+        } else if (params.action === "switch-authority") {
+          if (!params.authority || params.expectedRevision === undefined) throw new Error("authority and expectedRevision are required for switch-authority");
+          value = await switchInitializationAuthority(project, params.authority, params.expectedRevision, { compatibilityExport: params.compatibilityExport });
+        } else if (params.action === "restore") {
+          if (!params.targetPath) throw new Error("targetPath is required for restore");
+          await InitializationStore.restore(project, path.resolve(project.root, params.targetPath)); value = { restored: true, database: project.controlDatabasePath };
+        } else {
+          const store = await InitializationStore.open(project);
+          try {
+            if (params.action === "run-status") {
+              if (!params.runId) throw new Error("runId is required for run-status");
+              value = store.getRun(params.runId);
+            } else if (params.action === "config") {
+              value = store.getInitializationConfiguration(params.workspaceId ?? project.workspaceId);
+            } else if (params.action === "workspaces") {
+              value = store.listWorkspaces();
+            } else if (params.action === "rebind-workspace") {
+              if (!params.workspaceId) throw new Error("workspaceId is required for rebind-workspace");
+              value = await store.registerWorkspace({ rebindWorkspaceId: params.workspaceId });
+            } else if (params.action === "cancel") {
+              if (!params.runId) throw new Error("runId is required for cancel");
+              value = { runId: params.runId, cancelled: store.cancelRun(params.runId) };
+            } else if (params.action === "recover") {
+              if (!params.runId) throw new Error("runId is required for recover");
+              value = { runId: params.runId, ...store.recoverRun(params.runId) };
+            } else if (params.action === "authority") {
+              value = store.getAuthority();
+            } else if (params.action === "backup") {
+              if (!params.targetPath) throw new Error("targetPath is required for backup");
+              const target = path.resolve(project.root, params.targetPath);
+              if (target !== project.root && !target.startsWith(`${project.root}${path.sep}`)) throw new Error("Backup path escapes project root");
+              await store.backup(target); value = { backup: target };
+            } else if (params.action === "diff") {
+              if (!params.fromSnapshotId || !params.toSnapshotId) throw new Error("fromSnapshotId and toSnapshotId are required for diff");
+              value = store.compareSnapshots(params.fromSnapshotId, params.toSnapshotId);
+            } else if (params.snapshotId) {
+              value = store.queryContext({ snapshotId: params.snapshotId, kind: params.kind, repository: params.repository, after: params.after, limit: params.limit });
+            } else {
+              value = store.queryCurrent(project.workspaceId, { kind: params.kind, repository: params.repository, after: params.after, limit: params.limit });
+            }
+          } finally { store.close(); }
+        }
+        return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }], details: value };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text" as const, text: message }], details: { error: message }, isError: true };
+      }
+    },
+  });
   // CLI --resume means "continue this chat session" at the OMP layer. The
   // launcher also supplies this one-shot, process-owned signal so Devflow can
   // safely resume an authoritative incomplete workflow step. It is consumed
@@ -1635,7 +1779,7 @@ export default function devflowCore(pi: ExtensionAPI) {
     if (isEmbeddedRuntime()) {
       add("config", "pass", "embedded Devflow Pi owns the managed runtime profile");
     } else if (!existsSync(configPath)) {
-      add("config", "fail", "missing .omp/config.yml; run bash .skills/install.sh --apply");
+      add("config", "fail", "missing .omp/config.yml; configure the OMP project profile before starting");
     } else {
       const config = readFileSync(configPath, "utf8");
       const requiredConfigPatterns: Array<[string, RegExp]> = [
@@ -3716,10 +3860,11 @@ export default function devflowCore(pi: ExtensionAPI) {
   pi.registerTool({
     name: "devflow_skill_script",
     label: "Devflow Skill Script",
-    description: "Run an allowlisted deterministic script bundled with a Devflow skill. project-context-validate is a final initialization gate: call it only after all manifest outputs and current-run markers are written.",
+    description: "Run an allowlisted deterministic script bundled with a Devflow skill. Database validation is the authority for new initialization runs; the manifest validator is legacy compatibility only.",
     parameters: z.object({
       script: z.enum([
         "project-context-validate",
+        "project-context-db-validate",
         "orchestrator-manage-lessons",
         "orchestrator-update-triage",
         "wireframe-validate",
@@ -3731,6 +3876,7 @@ export default function devflowCore(pi: ExtensionAPI) {
       const kitRoot = resolveKitRoot(ctx.cwd);
       const scripts: Record<string, [string, string]> = {
         "project-context-validate": ["python3", "workflow-project-context/scripts/validate_initialization.py"],
+        "project-context-db-validate": ["python3", "workflow-project-context/scripts/validate_initialization_database.py"],
         "orchestrator-manage-lessons": ["ruby", "workflow-orchestrator/scripts/manage_lessons.rb"],
         "orchestrator-update-triage": ["ruby", "workflow-orchestrator/scripts/update_triage_route.rb"],
         "wireframe-validate": ["python3", "workflow-orchestrator/scripts/wireframe_validate.py"],

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

@@ -4,6 +4,39 @@ from __future__ import annotations
 
 from pathlib import Path
 from typing import Any
+import json
+import os
+import sqlite3
+
+
+def database_toolchain(root: Path) -> list[str] | None:
+    manifest_path = root / ".devflow" / "project.json"
+    if not manifest_path.is_file():
+        return None
+    try:
+        project_id = json.loads(manifest_path.read_text(encoding="utf-8"))["projectId"]
+        data_home = Path(os.environ.get("DEVFLOW_HOME", Path.home() / ".devflow-pi"))
+        database = data_home / "projects" / project_id / "control.db"
+        connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True)
+        connection.row_factory = sqlite3.Row
+        try:
+            authority = connection.execute("SELECT authority FROM authority_state WHERE project_id=?", (project_id,)).fetchone()
+            if not authority or authority["authority"] != "database":
+                return None
+            rows = connection.execute(
+                """SELECT f.value_json FROM workspaces w
+                   JOIN current_context c ON c.workspace_id=w.id
+                   JOIN context_snapshots s ON s.id=c.snapshot_id
+                   JOIN facts f ON f.run_id=s.run_id AND f.kind='toolchain'
+                   WHERE w.project_id=? AND w.location=?
+                   ORDER BY c.revision DESC""",
+                (project_id, str(root.resolve())),
+            ).fetchall()
+            return [str(json.loads(row["value_json"]).get("command", "")) for row in rows]
+        finally:
+            connection.close()
+    except (OSError, KeyError, ValueError, json.JSONDecodeError, sqlite3.Error):
+        return None
 
 
 def runner_marker(argv: list[str]) -> str | None:
@@ -43,11 +76,15 @@ def validate_test_command(root: Path, argv: Any) -> str | None:
     marker = runner_marker(argv)
     if marker is None:
         return "test command runner is not in the Core allowlist"
-    toolchain = root / ".planning" / "toolchain.md"
-    if not toolchain.is_file():
-        return "initialized .planning/toolchain.md is required before Core can execute a test command"
-    content = toolchain.read_text(encoding="utf-8").lower()
+    commands = database_toolchain(root)
+    if commands is None:
+        toolchain = root / ".planning" / "toolchain.md"
+        if not toolchain.is_file():
+            return "initialized toolchain context (database or .planning/toolchain.md compatibility projection) is required before Core can execute a test command"
+        content = toolchain.read_text(encoding="utf-8").lower()
+    else:
+        content = "\n".join(commands).lower()
     aliases = {"pytest": ("pytest",), "unittest": ("unittest",), "bun test": ("bun test",), "npm": ("npm",), "pnpm": ("pnpm",), "yarn": ("yarn",), "go test": ("go test",), "newman": ("newman",), "playwright": ("playwright",), "vitest": ("vitest",)}
     if not any(alias in content for alias in aliases[marker]):
-        return f"test runner '{marker}' was not discovered in .planning/toolchain.md"
+        return f"test runner '{marker}' was not discovered in the initialization toolchain snapshot"
     return None