@guanlin4924/devflow-pi 0.1.0

package/src/runtime.ts

@@ -0,0 +1,167 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+
+import { OMP_RUNTIME_VERSION, PRODUCT_NAME, PRODUCT_VERSION } from "./constants.ts";
+import { createPlatformExtension } from "./platform-extension.ts";
+import { devflowAgentDir, devflowHome, pluginRoots, projectSessionDir, sharedOmpAgentDir } from "./paths.ts";
+import type { ProjectContext } from "./project-context.ts";
+
+export interface RuntimeOptions {
+  initialPrompt?: string;
+  originalOmpAgentDir?: string;
+  resume?: boolean | string;
+  hasUI?: boolean;
+  enableMCP?: boolean;
+  enableLsp?: boolean;
+}
+
+const MANAGED_SETTINGS: Record<string, unknown> = {
+  modelRoleStorage: "user",
+  disabledProviders: ["claude", "codex", "cursor", "gemini", "github", "opencode"],
+  "skills.enabled": true,
+  "skills.enableSkillCommands": true,
+  "skills.enableClaudeUser": false,
+  "skills.enableClaudeProject": false,
+  "skills.enableCodexUser": false,
+  "skills.enablePiUser": false,
+  "skills.enablePiProject": false,
+  "skills.enableAgentsUser": false,
+  "skills.enableAgentsProject": false,
+  // The interactive session is the high-capability Planner. Low-cost agents
+  // are dispatched only through explicit Devflow steps, one at a time by
+  // default, so background work cannot silently widen a user's request.
+  "modelRoles.default": "@slow",
+  "task.batch": false,
+  "task.maxConcurrency": 1,
+  "task.maxRecursionDepth": 1,
+  "task.enableLsp": true,
+  "task.agentModelOverrides": {
+    "project-scout": "@smol",
+    "requirements-auditor": "@slow",
+    "contract-auditor": "@slow",
+    "implementation-worker": "@task",
+    "devflow-code-reviewer": "@slow",
+    "verification-runner": "@task",
+  },
+  "task.isolation.mode": "auto",
+  "task.isolation.apply": false,
+  "lsp.enabled": true,
+  "lsp.lazy": true,
+  "lsp.diagnosticsOnWrite": true,
+  "tools.approvalMode": "write",
+};
+
+export async function createEmbeddedRuntime(project: ProjectContext, options: RuntimeOptions = {}) {
+  const productAgentDir = devflowAgentDir();
+  const productHome = devflowHome();
+  const sharedAgentDir = sharedOmpAgentDir(options.originalOmpAgentDir);
+  const sessionDir = projectSessionDir(project.manifest.projectId);
+  // OMP's logger uses its state root rather than PI_CODING_AGENT_DIR. Keep
+  // embedded Devflow logs private as well, including in sandboxed test runs.
+  await Promise.all([
+    mkdir(productAgentDir, { recursive: true }),
+    mkdir(sessionDir, { recursive: true }),
+    mkdir(path.join(productHome, "omp"), { recursive: true }),
+    mkdir(path.join(productHome, "logs"), { recursive: true }),
+  ]);
+
+  process.env.PI_CODING_AGENT_DIR = productAgentDir;
+  process.env.XDG_STATE_HOME = productHome;
+  process.env.DEVFLOW_RUNTIME_MODE = "embedded";
+  process.env.DEVFLOW_PROJECT_ROOT = project.root;
+  process.env.DEVFLOW_PLUGIN_ROOT = path.join(path.dirname(pluginRoots()[0]), "");
+  process.env.DEVFLOW_SESSION_ROOT = sessionDir;
+
+  // Configure logging before importing the OMP SDK. The SDK's default is
+  // ~/.omp/logs, which would break the product/session isolation boundary.
+  const utils = await import("@oh-my-pi/pi-utils");
+  utils.logger.setTransports({ file: path.join(productHome, "logs") });
+  const omp = await import("@oh-my-pi/pi-coding-agent");
+  const roots = pluginRoots();
+  const configFiles = [path.join(sharedAgentDir, "config.yml"), path.join(sharedAgentDir, "config.yaml")].filter(
+    candidate => existsSync(candidate),
+  );
+  const settings = await omp.Settings.init({
+    cwd: project.root,
+    agentDir: productAgentDir,
+    configFiles,
+    overrides: {
+      ...MANAGED_SETTINGS,
+      // OMP 17.2.7 classifies extension-package skills behind the generic
+      // third-party toggle. Explicit custom roots keep ambient providers off
+      // while guaranteeing the packaged Devflow skills are present.
+      "skills.customDirectories": roots.map(root => path.join(root, "skills")),
+    } as never,
+  });
+  const authStorage = await omp.discoverAuthStorage(sharedAgentDir);
+  const modelRegistry = new omp.ModelRegistry(authStorage, path.join(sharedAgentDir, "models.yml"));
+  modelRegistry.refreshInBackground();
+  let sessionManager;
+  if (typeof options.resume === "string") {
+    const sessions = await omp.SessionManager.list(project.root, sessionDir);
+    const exact = sessions.find(session => session.id === options.resume);
+    const candidates = exact ? [exact] : sessions.filter(session => session.id.startsWith(options.resume as string));
+    if (candidates.length === 0) throw new Error(`Devflow session not found in this project: ${options.resume}`);
+    if (candidates.length > 1) throw new Error(`Devflow session id is ambiguous in this project: ${options.resume}`);
+    const matched = candidates[0];
+    sessionManager = await omp.SessionManager.open(matched.path, sessionDir);
+  } else if (options.resume) {
+    sessionManager = await omp.SessionManager.continueRecent(project.root, sessionDir);
+  } else {
+    sessionManager = omp.SessionManager.create(project.root, sessionDir);
+  }
+  const runtime = await omp.createAgentSession({
+    cwd: project.root,
+    agentDir: productAgentDir,
+    settings,
+    authStorage,
+    modelRegistry,
+    sessionManager,
+    additionalExtensionPaths: roots,
+    disableExtensionDiscovery: true,
+    extensions: [
+      createPlatformExtension({
+        sessionRoot: sessionDir,
+        projectId: project.manifest.projectId,
+      }),
+    ],
+    hasUI: options.hasUI ?? true,
+    enableMCP: options.enableMCP ?? false,
+    enableLsp: options.enableLsp ?? true,
+  });
+  return { omp, runtime, sessionDir };
+}
+
+export async function runInteractiveRuntime(project: ProjectContext, options: RuntimeOptions = {}): Promise<void> {
+  const { omp, runtime } = await createEmbeddedRuntime(project, {
+    ...options,
+    hasUI: true,
+  });
+  const { initTheme } = await import("@oh-my-pi/pi-coding-agent/modes/theme/theme");
+  await initTheme(
+    true,
+    runtime.session.settings.get("symbolPreset"),
+    runtime.session.settings.get("colorBlindMode"),
+    runtime.session.settings.get("theme.dark"),
+    runtime.session.settings.get("theme.light"),
+  );
+  const mode = new omp.InteractiveMode(
+    runtime.session,
+    `${OMP_RUNTIME_VERSION} · ${PRODUCT_NAME} ${PRODUCT_VERSION}`,
+    undefined,
+    runtime.setToolUIContext,
+    runtime.lspServers,
+    runtime.mcpManager,
+    runtime.eventBus,
+  );
+  await mode.init({ clearInitialTerminalHistory: true });
+  mode.renderInitialMessages({ preserveExistingChat: true, clearTerminalHistory: true });
+  mode.showStatus(`Devflow project ${project.manifest.name} · ${project.manifest.projectId.slice(0, 8)}`);
+  if (runtime.modelFallbackMessage) mode.showWarning(runtime.modelFallbackMessage);
+  if (options.initialPrompt) await runtime.session.prompt(options.initialPrompt);
+  while (true) {
+    const input = await mode.getUserInput();
+    await omp.submitInteractiveInput(mode, runtime.session, input);
+  }
+}

package/src/usage-stats.ts

@@ -0,0 +1,101 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+
+export interface UsageTotals {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  totalTokens: number;
+  cost: number;
+  assistantMessages: number;
+  sessionFiles: number;
+}
+
+function emptyUsage(): UsageTotals {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: 0,
+    assistantMessages: 0,
+    sessionFiles: 0,
+  };
+}
+
+function finiteNumber(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function includeTimestamp(timestamp: unknown, from?: string, to?: string): boolean {
+  if (!from && !to) return true;
+  if (typeof timestamp !== "string") return false;
+  const value = Date.parse(timestamp);
+  if (!Number.isFinite(value)) return false;
+  if (from && value < Date.parse(`${from}T00:00:00.000Z`)) return false;
+  if (to && value > Date.parse(`${to}T23:59:59.999Z`)) return false;
+  return true;
+}
+
+async function jsonlFiles(root: string): Promise<string[]> {
+  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+  const nested = await Promise.all(
+    entries.map(async entry => {
+      const target = path.join(root, entry.name);
+      if (entry.isDirectory()) return jsonlFiles(target);
+      return entry.isFile() && entry.name.endsWith(".jsonl") ? [target] : [];
+    }),
+  );
+  return nested.flat();
+}
+
+export async function aggregateUsage(
+  sessionRoot: string,
+  range: { from?: string; to?: string } = {},
+): Promise<UsageTotals> {
+  const totals = emptyUsage();
+  const files = await jsonlFiles(sessionRoot);
+  totals.sessionFiles = files.length;
+  for (const file of files) {
+    const content = await readFile(file, "utf8").catch(() => "");
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      let entry: Record<string, unknown>;
+      try {
+        entry = JSON.parse(line) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+      if (entry.type !== "message" || !includeTimestamp(entry.timestamp, range.from, range.to)) continue;
+      const message = entry.message as Record<string, unknown> | undefined;
+      if (message?.role !== "assistant") continue;
+      const usage = message.usage as Record<string, unknown> | undefined;
+      if (!usage) continue;
+      const cost = usage.cost as Record<string, unknown> | undefined;
+      totals.input += finiteNumber(usage.input);
+      totals.output += finiteNumber(usage.output);
+      totals.cacheRead += finiteNumber(usage.cacheRead);
+      totals.cacheWrite += finiteNumber(usage.cacheWrite);
+      totals.totalTokens += finiteNumber(usage.totalTokens);
+      totals.cost += finiteNumber(cost?.total);
+      totals.assistantMessages += 1;
+    }
+  }
+  return totals;
+}
+
+export function renderUsage(totals: UsageTotals): string {
+  return [
+    "Devflow usage",
+    `sessions: ${totals.sessionFiles}`,
+    `assistant messages: ${totals.assistantMessages}`,
+    `input: ${totals.input}`,
+    `output: ${totals.output}`,
+    `cache read: ${totals.cacheRead}`,
+    `cache write: ${totals.cacheWrite}`,
+    `total tokens: ${totals.totalTokens}`,
+    `cost: $${totals.cost.toFixed(6)}`,
+  ].join("\n");
+}

package/templates/commands/start.md

@@ -0,0 +1,58 @@
+# 研发会话初始化
+
+当 `<workflow>`、`<index-entrypoints>` 和 `<pipeline-state>` 已由 SessionStart hook 注入时，按以下指令执行。
+
+---
+
+## 初始化行为
+
+### 1. 如果有 `<intent>` 块（跨 /clear 意图）
+
+根据 intent 中的 action 执行：
+
+- **`"action": "continue"`** → 直接按 `<workflow>` 从 `<pipeline-state>` 的当前步骤继续，**不要问用户**。简短告知后将下一步的 skill 调起来。
+- **`"action": "skill", "skill": "workflow-xxx", "args": "..."`** → 直接调用该 skill，**不要问用户**。
+
+### 2. 如果没有 `<intent>` 块（正常启动或手动 /clear）
+
+汇报当前流水线状态（基于 `<pipeline-state>`）：
+- 已完成步骤和产物
+- 当前卡在哪一步
+- 推荐下一步操作
+
+检查 git 状态：
+- 当前分支
+- 最近 3 条提交
+- 是否有未提交的变更
+
+询问用户：
+
+> **接下来做什么？**
+>
+> - 继续当前功能（继续推荐下一步）
+> - 开始新功能：提供功能名 + 需求描述
+> - 其他操作
+
+---
+
+## 跨步骤上下文管理
+
+**关键约定**：当用户要求进入下一个 workflow 步骤时（说"继续"、"下一步"、或直接调用 workflow skill），在执行新 skill 之前先做两件事：
+
+1. 写入 `.planning/.next-intent`：
+   - 继续下一步：`{"action": "continue"}`
+   - 调用指定 skill：`{"action": "skill", "skill": "workflow-verify-work", "args": "..."}`
+2. 执行 `/clear`
+
+`/clear` 后 SessionStart hook 重新注入上下文，`<intent>` 块会告知此会话的意图，无需再问用户即可直接进入下一步。
+
+**重要**：只在需要切换 workflow 步骤时才做这个流程。用户中间的提问、讨论、代码审查等正常对话不要 `/clear`。
+
+## 执行中的行为准则
+
+- workflow skill 使用 `skill://<name>` 按需读取（如 `skill://workflow-verify-work`）。
+- 上下文管理：你觉得需要时就 `/clear`，不要等 compaction。`/clear` 后 hook 会自动恢复 pipeline 状态和索引入口。
+- 优先读取最新的规则、规范和导航索引；索引缺失或过期时回退到 LSP、搜索和源码事实，并显式报告降级状态
+- 读 `.context/lessons/README.md`，避免已知陷阱
+- 每个步骤完成后更新 `.planning/STATE.md`
+- 遇到不确定的情况，在 `.context/lessons/` 中记录

package/templates/omp/AGENTS.md

@@ -0,0 +1,36 @@
+# Devflow Project Agent
+
+This repository uses an OMP-native, project-scoped software delivery runtime.
+
+## Control plane
+
+- Start only through `/devflow start <feature>|<phase>` after `/devflow doctor` passes; resume with `/devflow resume`.
+- Inspect workflow state with `devflow_state`; do not infer state from chat history.
+- Initialize delivery with `devflow_bootstrap`.
+- Mutate checkpoints and steps only with `devflow_transition`.
+- Never directly edit `.planning/STATE.md`, `.planning/.next-intent`, `.planning/workflows/`, or `.planning/artifacts/index.yaml`.
+- The parent session is the only workflow-state writer. Task agents return evidence or patches and never advance state.
+
+## Evidence order
+
+1. Read the smallest relevant project index when it exists and is current.
+2. Verify material claims with LSP, targeted search, tests, and source code.
+3. If an index is absent or stale, continue from source-of-truth evidence and explicitly report degraded index coverage.
+
+An index accelerates discovery; it never overrides source code, executable tests, or an approved contract.
+
+## Skills and roles
+
+- Load skills on demand with `skill://<name>`; do not preload the entire library.
+- Use `project-scout` for read-only repository exploration.
+- Use `requirements-auditor` and `contract-auditor` as adversarial reviewers, not decision authorities.
+- Use `implementation-worker` only for an approved bounded plan and in task isolation.
+- Use `devflow-code-reviewer` and `verification-runner` independently from implementation.
+- Do not silently inherit the parent model for task agents. `@smol`, `@task`, and `@slow` must resolve to distinct project models before automatic delivery starts.
+
+## Completion
+
+- A model assertion is not validation evidence.
+- Record exact commands and results for tests, builds, migrations, and acceptance checks.
+- When context reconciliation is requested, follow `skill://workflow-context-sync`, validate the required level, then acknowledge through `devflow_context_sync`.
+- Human checkpoints never pass silently in headless mode.

package/templates/omp/config.yml

@@ -0,0 +1,112 @@
+# Devflow owns this project-local OMP profile. Model ids stay in the user's
+# global config; only role storage and development policy are project-scoped.
+modelRoleStorage: project
+
+# Do not import competing editor/harness configuration into this dedicated Pi.
+# These are discovery-source ids, not model-provider ids.
+disabledProviders:
+  - claude
+  - codex
+  - cursor
+  - gemini
+  - github
+  - opencode
+
+skills:
+  enabled: true
+  # /devflow is the canonical entry. /skill:* remains enabled for diagnosis and
+  # manual recovery; state transitions are still enforced by Devflow tools.
+  enableSkillCommands: true
+  customDirectories:
+    - .skills/plugins/devflow-core/skills
+    - .skills/plugins/devflow-intel/skills
+    - .skills/plugins/devflow-requirements/skills
+    - .skills/plugins/devflow-design/skills
+    - .skills/plugins/devflow-implementation/skills
+    - .skills/plugins/devflow-quality/skills
+  includeSkills:
+    - code-index-query
+    - code-review
+    - requirement-feasibility-review
+    - workflow-api-call-guide
+    - workflow-api-contract
+    - workflow-api-supplement
+    - workflow-audit-milestone
+    - workflow-backend-tech-spec
+    - workflow-bug-fix
+    - workflow-change-plan
+    - workflow-code-index
+    - workflow-complete-milestone
+    - workflow-context-sync
+    - workflow-demand-clarify
+    - workflow-design-rule-pack
+    - workflow-domain-modeling
+    - workflow-execute-phase
+    - workflow-feature-breakdown
+    - workflow-frontend-tech-spec
+    - workflow-generate-mainflow-cases
+    - workflow-integration-verify
+    - workflow-orchestrator
+    - workflow-pipeline
+    - workflow-project-context
+    - workflow-requirement-baseline
+    - workflow-requirement-triage
+    - workflow-ui-spec
+    - workflow-update-navigation
+    - workflow-verify-work
+    - workflow-wayfinder
+  enableClaudeUser: false
+  enableClaudeProject: false
+  enableCodexUser: false
+  enablePiUser: false
+  enablePiProject: false
+  enableAgentsUser: false
+  enableAgentsProject: false
+
+task:
+  batch: true
+  maxConcurrency: 4
+  maxRecursionDepth: 1
+  enableLsp: true
+  # Agent-name overrides take precedence over agent frontmatter and parent-model
+  # inheritance. /devflow doctor refuses to start until @smol, @task, and @slow
+  # resolve to three distinct authenticated models in the project role store.
+  agentModelOverrides:
+    project-scout: "@smol"
+    requirements-auditor: "@slow"
+    contract-auditor: "@slow"
+    implementation-worker: "@task"
+    devflow-code-reviewer: "@slow"
+    verification-runner: "@task"
+  isolation:
+    mode: auto
+    apply: false
+
+lsp:
+  enabled: true
+  lazy: true
+  diagnosticsOnWrite: true
+
+tools:
+  approvalMode: write
+  approval:
+    read: allow
+    grep: allow
+    find: allow
+    lsp: allow
+    bash: prompt
+    devflow_doctor: allow
+    devflow_state: allow
+    devflow_bootstrap: prompt
+    devflow_transition: prompt
+    devflow_artifact: prompt
+    devflow_code_index: allow
+    devflow_context_cursor: prompt
+    devflow_design_rule: prompt
+    devflow_mainflow: prompt
+    devflow_skill_script: prompt
+    devflow_context_sync: allow
+
+advisor:
+  enabled: false
+  subagents: false

package/templates/omp/hook-config.json

@@ -0,0 +1,18 @@
+{
+  "sources": {
+    "state": ".planning/STATE.md",
+    "workflow": ".context/workflow.md",
+    "indexes": [
+      ".planning/rules/INDEX.md",
+      ".context/spec/index.md",
+      ".planning/navigation/INDEX.md",
+      ".planning/code-index/INDEX.md"
+    ],
+    "lessons": ".context/lessons/README.md"
+  },
+  "gates": {
+    "index_first": {
+      "policy": ".agent-gates/index-first.json"
+    }
+  }
+}

package/templates/omp/index-policy.json

@@ -0,0 +1,57 @@
+{
+  "version": 2,
+  "mode": "advisory",
+  "protected_roots": [],
+  "required_evidence": [
+    ".planning/rules/INDEX.md",
+    ".context/spec/index.md",
+    ".planning/navigation/INDEX.md"
+  ],
+  "optional_evidence": [
+    ".planning/code-index/INDEX.md"
+  ],
+  "allowed_before_gate": [
+    "AGENTS.md",
+    "README.md",
+    ".omp/**",
+    ".planning/**",
+    ".context/**",
+    ".agent-gates/**",
+    ".skills/**"
+  ],
+  "context_sync": {
+    "enabled": true,
+    "auto_light": true,
+    "light_timeout_seconds": 120,
+    "full_file_threshold": 30,
+    "ignore": [
+      ".omp/**",
+      ".planning/**",
+      ".context/**",
+      ".agent-gates/**",
+      ".skills/**"
+    ],
+    "medium_patterns": [
+      "**/routes.*",
+      "**/router.*",
+      "**/routes/**",
+      "**/api/**",
+      "**/*handler.*",
+      "**/controllers/**",
+      "**/migrations/**",
+      "package.json",
+      "**/package.json",
+      "go.mod",
+      "**/go.mod",
+      "Cargo.toml",
+      "**/Cargo.toml",
+      "pyproject.toml",
+      "**/pyproject.toml",
+      "Makefile",
+      "**/Makefile",
+      "**/vite.config.*",
+      "**/next.config.*"
+    ],
+    "full_patterns": []
+  }
+}