@ghyper9023/pi-dev-workflow 0.2.0 → 0.3.1

package/extensions/sub-agents.ts

@@ -35,53 +35,69 @@ const PROGRESS_INTERVAL_MS = 1_500;
 /** Hard limit on accumulated output per subagent (prevents OOM on runaway). */
 const MAX_BUFFER_BYTES = 500_000;
 
-/** Locations to auto-load APPEND_SYSTEM.md / append.system.md from (checked in order). */
-const APPEND_SYSTEM_PATHS = [
-	path.join(osHomedir(), ".pi", "agent", "append.system.md"),
-	".pi/append.system.md",
-	"APPEND_SYSTEM.md",
-];
+/**
+ * Locations to auto-load APPEND_SYSTEM.md / append.system.md from (checked in order).
+ * Defined as a getter so that osHomedir() is called lazily rather than at module init,
+ * avoiding a potential crash when the module is loaded in restricted environments.
+ */
+function getAppendSystemPaths(): string[] {
+	return [
+		path.join(osHomedir(), ".pi", "agent", "append.system.md"),
+		".pi/append.system.md",
+		"APPEND_SYSTEM.md",
+	];
+}
 
-// Lazily resolved
-let _appendSystemContent: string | null | undefined; // undefined = not checked yet
+/** Cache for append.system.md content, keyed by cwd to support multi-project isolation. */
+const _appendSystemCache = new Map<string, string | null>();
 
 function loadAppendSystem(cwd: string): string | null {
-	if (_appendSystemContent !== undefined) return _appendSystemContent;
-	for (const loc of APPEND_SYSTEM_PATHS) {
+	const cached = _appendSystemCache.get(cwd);
+	if (cached !== undefined) return cached;
+	for (const loc of getAppendSystemPaths()) {
 		const abs = path.isAbsolute(loc) ? loc : path.join(cwd, loc);
 		try {
 			const content = fs.readFileSync(abs, "utf-8").trim();
 			if (content) {
-				_appendSystemContent = content;
+				_appendSystemCache.set(cwd, content);
 				return content;
 			}
 		} catch {
 			// file not found or unreadable, try next
 		}
 	}
-	_appendSystemContent = null;
+	_appendSystemCache.set(cwd, null);
 	return null;
 }
 
-/** Find the newest HTML review file in pi-review/ directory. */
+/** Find the newest HTML review file in pi-review/ or pi-dev-output/pi-review/ directory. */
 function findNewestReviewHtml(cwd: string): string {
-	try {
-		const reviewDir = path.join(cwd, "pi-review");
-		if (fs.existsSync(reviewDir)) {
-			const files = fs.readdirSync(reviewDir)
-				.filter(f => f.endsWith(".html"))
-				.map(f => ({
-					name: f,
-					mtime: fs.statSync(path.join(reviewDir, f)).mtimeMs,
-				}))
-				.sort((a, b) => b.mtime - a.mtime);
-			if (files.length > 0) {
-				return "pi-review/" + files[0].name;
+	const candidates = [
+		path.join(cwd, "pi-review"),
+		path.join(cwd, "pi-dev-output", "pi-review"),
+	];
+
+	for (const reviewDir of candidates) {
+		try {
+			if (fs.existsSync(reviewDir)) {
+				const files = fs.readdirSync(reviewDir)
+					.filter(f => f.endsWith(".html"))
+					.map(f => ({
+						name: f,
+						mtime: fs.statSync(path.join(reviewDir, f)).mtimeMs,
+					}))
+					.sort((a, b) => b.mtime - a.mtime);
+				if (files.length > 0) {
+					// Return relative path from cwd
+					const rel = path.relative(cwd, reviewDir);
+					return rel + "/" + files[0].name;
+				}
 			}
+		} catch {
+			// ignore fs errors
 		}
-	} catch {
-		// ignore fs errors
 	}
+
 	return "";
 }
 
@@ -108,7 +124,10 @@ function osHomedir(): string {
 const activeChildren = new Set<import("node:child_process").ChildProcess>();
 
 function killAllChildren(): void {
-	for (const proc of activeChildren) {
+	// Snapshot the Set to avoid potential iteration issues if exit callbacks
+	// modify activeChildren during the loop.
+	const children = [...activeChildren];
+	for (const proc of children) {
 		try {
 			if (proc.pid !== undefined && !proc.killed) {
 				proc.kill("SIGTERM");
@@ -337,9 +356,7 @@ export async function spawnSubagent(
 				onProgress(`[${agent.name}] (${elapsed}s) ⏳ 处理中...`);
 			}
 		}, PROGRESS_INTERVAL_MS);
-		if (typeof progressTimer === "object" && "unref" in progressTimer) {
-			progressTimer.unref();
-		}
+		progressTimer.unref();
 
 		const settle = (result: SubagentResult) => {
 			if (settled) return;
@@ -402,7 +419,7 @@ export async function spawnSubagent(
 				durationMs: 0,
 			});
 		}, effectiveTimeout);
-		if (typeof timer === "object" && "unref" in timer) timer.unref();
+		timer.unref();
 
 		// ── Abort signal wiring ─────────────────────────────
 		if (signal) {
@@ -422,6 +439,7 @@ export function extractFinalOutput(jsonOutput: string): string {
 	// Parse JSON lines from --mode json output
 	// Try multiple event formats to find the final assistant response
 	let result = "";
+	let textEndSeen = false;
 
 	for (const line of jsonOutput.split("\n")) {
 		if (!line.trim()) continue;
@@ -430,7 +448,9 @@ export function extractFinalOutput(jsonOutput: string): string {
 
 			// Format 1: pi's --mode json message_update with text_delta (streaming)
 			//   {"type":"message_update","assistantMessageEvent":{"type":"text_delta","delta":"..."}}
-			if (event.type === "message_update" &&
+			// Once text_end has been seen, skip subsequent text_delta events to
+			// avoid appending stale deltas that arrive out of order.
+			if (!textEndSeen && event.type === "message_update" &&
 			    event.assistantMessageEvent?.type === "text_delta") {
 				result += event.assistantMessageEvent.delta || "";
 			}
@@ -441,6 +461,7 @@ export function extractFinalOutput(jsonOutput: string): string {
 			    event.assistantMessageEvent?.type === "text_end" &&
 			    event.assistantMessageEvent.content) {
 				result = event.assistantMessageEvent.content;
+				textEndSeen = true;
 			}
 
 			// Format 2: Anthropic-style message events

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghyper9023/pi-dev-workflow",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "keywords": [
     "pi-package"
   ],

package/skills/grill-with-docs/ADR-FORMAT.md

@@ -0,0 +1,47 @@
+# ADR Format
+
+ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.
+
+Create the `docs/adr/` directory lazily — only when the first ADR is needed.
+
+## Template
+
+```md
+# {Short title of the decision}
+
+{1-3 sentences: what's the context, what did we decide, and why.}
+```
+
+That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.
+
+## Optional sections
+
+Only include these when they add genuine value. Most ADRs won't need them.
+
+- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
+- **Considered Options** — only when the rejected alternatives are worth remembering
+- **Consequences** — only when non-obvious downstream effects need to be called out
+
+## Numbering
+
+Scan `docs/adr/` for the highest existing number and increment by one.
+
+## When to offer an ADR
+
+All three of these must be true:
+
+1. **Hard to reverse** — the cost of changing your mind later is meaningful
+2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
+3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
+
+If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."
+
+### What qualifies
+
+- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
+- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
+- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
+- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
+- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
+- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
+- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.

package/skills/grill-with-docs/CONTEXT-FORMAT.md

@@ -0,0 +1,77 @@
+# CONTEXT.md Format
+
+## Structure
+
+```md
+# {Context Name}
+
+{One or two sentence description of what this context is and why it exists.}
+
+## Language
+
+**Order**:
+{A concise description of the term}
+_Avoid_: Purchase, transaction
+
+**Invoice**:
+A request for payment sent to a customer after delivery.
+_Avoid_: Bill, payment request
+
+**Customer**:
+A person or organization that places orders.
+_Avoid_: Client, buyer, account
+
+## Relationships
+
+- An **Order** produces one or more **Invoices**
+- An **Invoice** belongs to exactly one **Customer**
+
+## Example dialogue
+
+> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
+> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed."
+
+## Flagged ambiguities
+
+- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts.
+```
+
+## Rules
+
+- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
+- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution.
+- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
+- **Show relationships.** Use bold term names and express cardinality where obvious.
+- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs.
+- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine.
+- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts.
+
+## Single vs multi-context repos
+
+**Single context (most repos):** One `CONTEXT.md` at the repo root.
+
+**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other:
+
+```md
+# Context Map
+
+## Contexts
+
+- [Ordering](./src/ordering/CONTEXT.md) — receives and tracks customer orders
+- [Billing](./src/billing/CONTEXT.md) — generates invoices and processes payments
+- [Fulfillment](./src/fulfillment/CONTEXT.md) — manages warehouse picking and shipping
+
+## Relationships
+
+- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking
+- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices
+- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money`
+```
+
+The skill infers which structure applies:
+
+- If `CONTEXT-MAP.md` exists, read it to find contexts
+- If only a root `CONTEXT.md` exists, single context
+- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved
+
+When multiple contexts exist, infer which one the current topic relates to. If unclear, ask.

package/skills/grill-with-docs/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: grill-with-docs
+description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
+---
+
+<what-to-do>
+
+Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
+
+Ask the questions one at a time, waiting for feedback on each question before continuing.
+
+If a question can be answered by exploring the codebase, explore the codebase instead.
+
+</what-to-do>
+
+<supporting-info>
+
+## Domain awareness
+
+During codebase exploration, also look for existing documentation:
+
+### File structure
+
+Most repos have a single context:
+
+```
+/
+├── CONTEXT.md
+├── docs/
+│   └── adr/
+│       ├── 0001-event-sourced-orders.md
+│       └── 0002-postgres-for-write-model.md
+└── src/
+```
+
+If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
+
+```
+/
+├── CONTEXT-MAP.md
+├── docs/
+│   └── adr/                          ← system-wide decisions
+├── src/
+│   ├── ordering/
+│   │   ├── CONTEXT.md
+│   │   └── docs/adr/                 ← context-specific decisions
+│   └── billing/
+│       ├── CONTEXT.md
+│       └── docs/adr/
+```
+
+Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
+
+## During the session
+
+### Challenge against the glossary
+
+When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
+
+### Sharpen fuzzy language
+
+When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
+
+### Discuss concrete scenarios
+
+When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
+
+### Cross-reference with code
+
+When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
+
+### Update CONTEXT.md inline
+
+When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
+
+`CONTEXT.md` should be totally devoid of implementation details. Do not treat `CONTEXT.md` as a spec, a scratch pad, or a repository for implementation decisions. It is a glossary and nothing else.
+
+### Offer ADRs sparingly
+
+Only offer to create an ADR when all three are true:
+
+1. **Hard to reverse** — the cost of changing your mind later is meaningful
+2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
+3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
+
+If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).
+
+</supporting-info>

package/skills/review-html/SKILL.md

@@ -4,9 +4,9 @@ description: review 代码并输出交互式 HTML 报告。适用于代码审查
 ---
 
 你是一个代码审查助手。用户要求你审查**当前代码库**的改动，具体包括：
-- `git diff` 相对于 HEAD 的所有未提交改动(未指明范围时默认行为，如diff无变动则默认最近1次commit,默认不允许探索整个代码库除非用户明确要求)
-- 最近 **2(或几个) 个 commit** 的完整改动（使用 `git log -p -n 2`）
-- 完整的整个代码库
+- `git diff HEAD` 相对于 HEAD 的所有未提交改动（如果无输出，则默认使用最近 1 次 commit 的改动 `git log -p -n 1`）。默认不允许探索整个代码库除非用户明确要求。
+- 最近 **2（或指定个数）个 commit** 的完整改动（使用 `git log -p -n <N>`）
+- 完整的整个代码库（需用户明确说明）
 
 ## 硬性输出要求
 
@@ -14,32 +14,43 @@ description: review 代码并输出交互式 HTML 报告。适用于代码审查
 **直接从 `<!DOCTYPE html>` 开始输出一个完整的、自包含的 HTML 文档。**
 **使用中文+英文专业名词**
 
-### review 的约束
+### 审查问题分类与重要程度
 
-1. **BUG**：发现潜在bug，重要程度：最高。
-2. **敏感信息**：敏感信息泄露，敏感信息文件在gitignore忘记添加，重要程度：高。
-3. **可维护性**：代码解耦，结构清晰，冗余代码优化，重要程度：中。
-4. **规范**：代码规范，代码风格，重要程度：低。
-6. **语法糖**：适合当前语言的高阶语法帮助优化代码，维持原逻辑和无bug>性能提升大>可读性>性能提升可忽略>缩短代码行数，重要程度：低。
-7. **其他**：其他问题。
+1. **BUG**：潜在 bug，最高优先级。
+2. **敏感信息**：敏感信息泄露、敏感文件未加入 `.gitignore`，高优先级。
+3. **可维护性**：代码解耦、结构清晰、冗余代码优化，中优先级。
+4. **规范**：代码规范、代码风格，低优先级。
+5. **语法糖**：适合当前语言的高阶语法优化，维持原逻辑和无 bug > 性能提升大 > 可读性 > 性能提升可忽略 > 缩短代码行数，低优先级。
+6. **其他**：其他问题。
 
-### HTML 内容的约束
+### HTML 内容约束
 
-1. **外观**：使用简单的现代 CSS（白/灰背景，清晰字体）。
-2. **交互**：如需：提供折叠/展开功能，便于快速浏览多个文件的审查意见。
-   - 默认只展示文件名称和问题数量，点击文件名可展开详细审查意见。
-3. **内容**：对于每个改动文件，至少包含：
-   - 文件路径
-   - 改动摘要（+/- 行数）
-   - 具体审查意见（潜在 bug、代码风格、可维护性等）
-4. **轻量**：不引用外部 CDN，全部内联（CSS,JS少量）。总 HTML 大小控制在 300 行以内(最大700行)，避免浪费 token。
+1. **外观**：简单的现代 CSS（白/灰背景，清晰字体）。全部内联，不引用外部 CDN。
+2. **交互**：提供折叠/展开功能，默认只展示文件名称和问题数量，点击文件名展开详细审查意见。
+3. **内容**：每个改动文件至少包含：文件路径、改动摘要（+/- 行数）、具体审查意见（问题分类及描述）。
+4. **轻量**：总 HTML 大小控制如下——审查整个代码库时上限为 2000 行（若代码库内容较少则仍遵循 700 行限制以保持简洁）；其他情况（diff / commit）严格控制在 700 行以内。CSS 和 JS 均为少量内联。
+
+### 特殊场景：简洁总结与评分
+
+当审查结果**没有任何重要程度为“高”或“最高”的问题**（即仅包含中、低或无问题）时，使用简洁 HTML 输出，不需要交互式折叠，仅展示：
+- 改动摘要
+- 总体评分（满分 100）及简短理由
+- 如果审查对象是**未提交的改动**，额外提供一条符合 Conventional Commits 规范的 commit message 建议（例如 `fix: 修复xxx`、`feat: 新增xxx`），从改动内容智能生成；若审查对象是已提交的 commit 或整个代码库，则只展示评分与总结，不提供 commit message。
+
+评分参考标准（严格、公正）：
+- **60 分（及格）**：存在少量中等问题，代码可运行但需改进。
+- **80 分（良好）**：仅有轻微（低）问题，整体质量较好。
+- **95 分（优秀）**：几乎无问题，设计清晰。
+- **99 分（完美）**：无可挑剔，代码典范。
+（实际得分根据问题数量与严重性严格判定）
 
 ## 执行步骤
 
-1. 运行 `git diff` 获取未暂存/未提交的改动或运行 `git log -p -n 2` 获取最近 2 个 commit 的详细改动或查看完整项目。
-2. 合并上述改动，按文件分组。
-3. 对每个改动文件进行审查，并生成上述 HTML。
+1. 根据用户指令运行 `git diff HEAD` 或 `git log -p -n <N>` 获取改动，或遍历代码库。
+2. 合并改动，按文件分组。
+3. 对每个文件进行审查，并生成符合上述要求的 HTML。
+4. 自动确保 `pi-dev-output/pi-review/` 文件夹存在于项目根目录，若不存在则创建；并确保 `pi-dev-output/` 下的 `.gitignore` 包含 `*`（忽略所有内容但保留目录）。
+5. HTML 文件命名格式：`年月日时分-任务简述(极简10词以内)-index.html`，若同名文件已存在则编号递增（如 `index1.html`）。
+6. 直接输出 HTML 文件到 `pi-dev-output/pi-review/` 目录，**不要添加任何解释性文字**，仅简短说明工作完成和输出文件路径即可。
 
-请立即输出 HTML 文件到项目根目录的pi-review文件夹(没有则创建，同时添加文件夹到gitignore)，不要加任何解释性文字,不需要输出大量md说明，简短说明工作完成和输出文件即可。
-HTML文件名称格式：年月日时分-任务简述(极简10词以内)-index.html，有同名则index+1。
-如果review未发现必须需要修改(重要程度>=中)的问题，如果改动未提交，则html简约输出只说明改动总结即可，无需交互，并在开头附带规范的git-commit信息便于用户提交。
+请严格遵循以上规则。

package/skills/to-prd/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: to-prd
+description: Turn the current conversation context into a PRD document and save it locally. Use when user wants to create a PRD from the current context.
+---
+
+This skill takes the current conversation context and codebase understanding and produces a PRD. Do NOT interview the user — just synthesize what you already know.
+
+## Process
+
+1. Explore the repo to understand the current state of the codebase, if you haven't already. Use the project's domain glossary vocabulary throughout the PRD, and respect any ADRs in the area you're touching.
+
+2. Sketch out the major modules you will need to build or modify to complete the implementation. Actively look for opportunities to extract deep modules that can be tested in isolation.
+
+A deep module (as opposed to a shallow module) is one which encapsulates a lot of functionality in a simple, testable interface which rarely changes.
+
+Check with the user that these modules match their expectations. Check with the user which modules they want tests written for.
+
+3. Write the PRD using the template below, then save it to `pi-dev-output/pi-prd/` directory.
+
+<prd-template>
+
+## Problem Statement
+
+The problem that the user is facing, from the user's perspective.
+
+## Solution
+
+The solution to the problem, from the user's perspective.
+
+## User Stories
+
+A LONG, numbered list of user stories. Each user story should be in the format of:
+
+1. As an <actor>, I want a <feature>, so that <benefit>
+
+<user-story-example>
+1. As a mobile bank customer, I want to see balance on my accounts, so that I can make better informed decisions about my spending
+</user-story-example>
+
+This list of user stories should be extremely extensive and cover all aspects of the feature.
+
+## Implementation Decisions
+
+A list of implementation decisions that were made. This can include:
+
+- The modules that will be built/modified
+- The interfaces of those modules that will be modified
+- Technical clarifications from the developer
+- Architectural decisions
+- Schema changes
+- API contracts
+- Specific interactions
+
+Do NOT include specific file paths or code snippets. They may end up being outdated very quickly.
+
+Exception: if a prototype produced a snippet that encodes a decision more precisely than prose can (state machine, reducer, schema, type shape), inline it within the relevant decision and note briefly that it came from a prototype. Trim to the decision-rich parts — not a working demo, just the important bits.
+
+## Testing Decisions
+
+A list of testing decisions that were made. Include:
+
+- A description of what makes a good test (only test external behavior, not implementation details)
+- Which modules will be tested
+- Prior art for the tests (i.e. similar types of tests in the codebase)
+
+## Out of Scope
+
+A description of the things that are out of scope for this PRD.
+
+## Further Notes
+
+Any further notes about the feature.
+
+</prd-template>