pi-gsd 1.12.3 → 2.0.0

package/.gsd/extensions/pi-gsd-hooks.ts

@@ -18,18 +18,20 @@
 
 import { execSync } from "node:child_process";
 import {
+	copyFileSync,
 	existsSync,
 	lstatSync,
 	mkdirSync,
 	readFileSync,
-	rmSync,
-	statSync,
-	symlinkSync,
+	readdirSync,
 	writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, relative } from "node:path";
 import type { ContextUsage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { processWxpTrustedContent, WxpProcessingError, readWorkflowVersionTag } from "../../src/wxp/index.js";
+import { DEFAULT_SHELL_ALLOWLIST } from "../../src/wxp/security.js";
+import type { WxpSecurityConfig } from "../../src/schemas/wxp.zod.js";
 
 /**
  * Ensures .pi/gsd/ in the project is a symlink to the harness files
@@ -37,61 +39,196 @@ import type { ContextUsage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
  * if already present. Never overwrites a real directory (user may have
  * customised it).
  */
-const ensureHarnessSymlink = (cwd: string): void => {
-	try {
-		const dest = join(cwd, ".pi", "gsd");
-		// If dest exists, verify it's a valid symlink with files inside.
-		// A stale real directory (from old build or worktree) must be replaced.
-		if (existsSync(dest)) {
+
+/**
+ * Copy-on-first-run harness distribution (HRN-01, HRN-03).
+ * - Detects symlinks and replaces with real file copies.
+ * - Copies missing files; never overwrites existing real files.
+ * - Silent on any failure (non-blocking).
+ */
+function copyHarness(
+	src: string,
+	dest: string,
+): { symlinksReplaced: number; filesCopied: number } {
+	let symlinksReplaced = 0;
+	let filesCopied = 0;
+
+	const walk = (srcDir: string, destDir: string): void => {
+		mkdirSync(destDir, { recursive: true });
+		const entries = readdirSync(srcDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const srcPath = join(srcDir, entry.name);
+			const destPath = join(destDir, entry.name);
+			if (entry.isDirectory()) {
+				walk(srcPath, destPath);
+				continue;
+			}
+			if (existsSync(destPath)) {
+				try {
+					const st = lstatSync(destPath);
+					if (st.isSymbolicLink()) {
+						// Replace symlink with real copy (HRN-03)
+						try {
+							// unlinkSync removes the symlink without following it
+							const { unlinkSync } = require("node:fs") as typeof import("node:fs");
+							unlinkSync(destPath);
+						} catch { /* ignore */ }
+						copyFileSync(srcPath, destPath);
+						symlinksReplaced++;
+					}
+					// Real file exists → skip (HRN-01: never overwrite)
+				} catch { /* ignore */ }
+				continue;
+			}
 			try {
-				const stat = statSync(dest);
-				if (stat.isSymbolicLink?.() || lstatSync(dest).isSymbolicLink()) return; // valid symlink, done
-				// Real directory — check if it has the expected files
-				if (existsSync(join(dest, "workflows", "execute-phase.md"))) return; // looks complete
-				// Stale/incomplete directory — remove and replace with symlink
-				rmSync(dest, { recursive: true, force: true });
-			} catch {
-				return; // can't inspect, leave it
+				copyFileSync(srcPath, destPath);
+				filesCopied++;
+			} catch { /* ignore */ }
+		}
+	};
+
+	walk(src, dest);
+	return { symlinksReplaced, filesCopied };
+}
+
+/**
+ * Extract the raw arguments string from a message that was produced by pi template expansion.
+ * Pi replaces $ARGUMENTS in prompt templates with the user's typed text.
+ * After <gsd-include> resolution, $ARGUMENTS text appears as trailing plain text
+ * at the end of the message — everything after the last WXP/include tag block.
+ *
+ * Example message after pi expansion + include resolution:
+ *   [workflow content with <gsd-execute> blocks...]
+ *   16 --auto
+ *
+ * Returns: "16 --auto"
+ */
+function extractRawArguments(content: string): string {
+	// Find the last <...> block (WXP tag or include) position
+	const lastTagEnd = (() => {
+		const tagPattern = /<\/(?:gsd-[a-zA-Z0-9_-]+|shell|if|then|else|condition|args|outs|string-op|settings)>/g;
+		let lastEnd = 0;
+		let m: RegExpExecArray | null;
+		while ((m = tagPattern.exec(content)) !== null) {
+			lastEnd = m.index + m[0].length;
+		}
+		return lastEnd;
+	})();
+
+	// Everything after the last closing tag is the trailing plain text ($ARGUMENTS expansion)
+	const trailing = content.slice(lastTagEnd).trim();
+
+	// Only return if it looks like user arguments (not a full document block)
+	// Reject if it contains markdown headings or is very long (probably included file content)
+	if (trailing.length === 0 || trailing.length > 500 || trailing.includes("\n\n\n")) {
+		return "";
+	}
+	return trailing;
+}
+
+export default function (pi: ExtensionAPI) {
+/** Resolve a single <gsd-include> match: file lookup + selector extraction. */
+function resolveGsdInclude(
+	match: RegExpMatchArray,
+	cwd: string,
+	pkgHarness: string,
+	errors: string[],
+): string | null {
+	const filePath = match[1];
+	const selectExpr = match[2] ?? "";
+
+	// ── Resolve file path ───────────────────────────────────────
+	const subPath = filePath.replace(/^\.pi\/gsd\//, "");
+	const candidates = [
+		join(cwd, filePath),
+		...(filePath.startsWith(".pi/gsd/") && pkgHarness
+			? [join(pkgHarness, subPath)]
+			: []),
+	];
+
+	let raw: string | null = null;
+	for (const c of candidates) {
+		try {
+			if (existsSync(c)) {
+				raw = readFileSync(c, "utf8");
+				break;
 			}
+		} catch {
+			/* try next */
 		}
+	}
+	if (raw === null) {
+		errors.push("File not found: " + filePath);
+		return null;
+	}
 
-		// Walk up from this extension file to the package root:
-		// <pkg>/.gsd/extensions/pi-gsd-hooks.ts → <pkg>
-		const extFile = typeof __filename !== "undefined" ? __filename : "";
-		const pkgRoot = join(dirname(extFile), "..", "..");
-		const harnessSrc = join(
-			pkgRoot,
-			".gsd",
-			"harnesses",
-			"pi",
-			"get-shit-done",
-		);
+	// ── Apply selector ─────────────────────────────────────────
+	let result = raw;
+	if (!selectExpr) return result;
 
-		if (!existsSync(harnessSrc)) return; // package incomplete — skip silently
+	const parts = selectExpr.split("|");
+	if (parts.length > 2) {
+		errors.push("Invalid selector (max 2 segments): " + selectExpr);
+		return null;
+	}
+	if (parts.length > 1 && parts.some((p) => p.trim().startsWith("lines:"))) {
+		errors.push("lines: cannot be chained — use it alone: " + selectExpr);
+		return null;
+	}
+
+	for (const part of parts) {
+		const p = part.trim();
 
-		mkdirSync(join(cwd, ".pi"), { recursive: true });
-		symlinkSync(harnessSrc, dest, "dir");
-	} catch {
-		/* silent — never block session startup */
+		if (p.startsWith("tag:")) {
+			const tagName = p.slice(4);
+			const tagRe = new RegExp("<" + tagName + ">([\\s\\S]*?)</" + tagName + ">", "i");
+			const tagMatch = result.match(tagRe);
+			if (!tagMatch) {
+				errors.push("Tag <" + tagName + "> not found in " + filePath);
+				return null;
+			}
+			result = tagMatch[1].trim();
+		} else if (p.startsWith("heading:")) {
+			const headingText = p.slice(8);
+			const escaped = headingText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			const headingRe = new RegExp("(^|\\n)(#{1,6})\\s+" + escaped + "\\s*\\n");
+			const hMatch = result.match(headingRe);
+			if (!hMatch) {
+				errors.push('Heading "' + headingText + '" not found in ' + filePath);
+				return null;
+			}
+			const level = hMatch[2].length;
+			const startIdx = (hMatch.index ?? 0) + hMatch[0].length;
+			const nextHeading = result.slice(startIdx).search(new RegExp("\\n#{1," + level + "}\\s"));
+			result =
+				nextHeading === -1
+					? result.slice(startIdx).trim()
+					: result.slice(startIdx, startIdx + nextHeading).trim();
+		} else if (p.startsWith("lines:")) {
+			const rangeMatch = p.match(/^lines:(\d+)-(\d+)$/);
+			if (!rangeMatch) {
+				errors.push("Invalid lines selector: " + p);
+				return null;
+			}
+			const start = parseInt(rangeMatch[1], 10) - 1;
+			const end = parseInt(rangeMatch[2], 10);
+			result = result.split("\n").slice(start, end).join("\n");
+		} else {
+			errors.push("Unknown selector: " + p);
+			return null;
+		}
 	}
-};
 
+	return result;
+}
 
-export default function (pi: ExtensionAPI) {
-	// ── input: <gsd-include> injection ───────────────────────────────────
-	// Replaces <gsd-include path="..." /> tags with actual file contents.
-	// Supports selectors: tag:NAME, heading:TEXT, lines:N-M
-	// Valid chains: tag|heading, tag|lines, heading|lines, heading|tag
-	// On ANY failure: red error + abort (action:"handled"). No partial injection.
-	pi.on("input", async (event, ctx) => {
-		if (event.source === "extension") return { action: "continue" };
-
-		const text = event.text;
+	// ── context: <gsd-include> injection ────────────────────────────────────────
+	// Fires AFTER template expansion, before each LLM call.
+	// Scans user messages for <gsd-include path="..." select="..." /> tags,
+	// resolves files, applies selectors, replaces tags with content.
+	// On ANY failure: red error + return empty messages to block the LLM call.
+	pi.on("context", async (event, ctx) => {
 		const includePattern = /<gsd-include\s+path="([^"]+)"(?:\s+select="([^"]*)")?\s*\/>/g;
-		const includes = [...text.matchAll(includePattern)];
-		ctx.ui.notify("[GSD] len=" + String(text?.length) + " inc=" + includes.length + " txt=[" + String(text).slice(0, 250) + "]", "info");
-		if (includes.length === 0) return { action: "continue" };
-
 
 		// Package harness fallback path
 		const extFile = typeof __filename !== "undefined" ? __filename : "";
@@ -100,124 +237,167 @@ export default function (pi: ExtensionAPI) {
 			: "";
 
 		const errors: string[] = [];
-		let transformed = text;
-
-		for (const match of includes) {
-			const fullMatch = match[0];
-			const filePath = match[1];
-			const selectExpr = match[2] ?? "";
-
-			// ── Resolve file path ───────────────────────────────────────
-			const subPath = filePath.replace(/^\.pi\/gsd\//, "");
-			const candidates = [
-				join(ctx.cwd, filePath),
-				...(filePath.startsWith(".pi/gsd/") && pkgHarness
-					? [join(pkgHarness, subPath)]
-					: []),
-			];
+		const messages = event.messages;
 
-			let raw: string | null = null;
-			for (const c of candidates) {
-				try {
-					if (existsSync(c)) { raw = readFileSync(c, "utf8"); break; }
-				} catch { /* try next */ }
-			}
-			if (raw === null) {
-				errors.push(`File not found: ${filePath}`);
-				continue;
-			}
+		for (const msg of messages) {
+			if (msg.role !== "user") continue;
+
+			// Handle both string content and content block arrays
+			if (typeof msg.content === "string") {
+				const includes = [...msg.content.matchAll(includePattern)];
+				if (includes.length === 0) continue;
 
-			// ── Apply selector ─────────────────────────────────────────
-			let result = raw;
-			if (selectExpr) {
-				const parts = selectExpr.split("|");
-				if (parts.length > 2) {
-					errors.push(`Invalid selector (max 2 segments): ${selectExpr}`);
-					continue;
+				let transformed = msg.content;
+				for (const match of includes) {
+					const replacement = resolveGsdInclude(match, ctx.cwd, pkgHarness, errors);
+					if (replacement === null) continue;
+					transformed = transformed.replace(match[0], replacement);
 				}
-				// lines: must be standalone — reject any chain involving lines
-				if (parts.length > 1 && parts.some((p) => p.trim().startsWith("lines:"))) {
-					errors.push(`lines: cannot be chained — use it alone: ${selectExpr}`);
-					continue;
+				msg.content = transformed;
+			} else if (Array.isArray(msg.content)) {
+				for (const block of msg.content) {
+					if (block.type !== "text" || !block.text) continue;
+					const includes = [...block.text.matchAll(includePattern)];
+					if (includes.length === 0) continue;
+
+					let transformed = block.text;
+					for (const match of includes) {
+						const replacement = resolveGsdInclude(match, ctx.cwd, pkgHarness, errors);
+						if (replacement === null) continue;
+						transformed = transformed.replace(match[0], replacement);
+					}
+					block.text = transformed;
 				}
+			}
+		}
 
-				for (let i = 0; i < parts.length; i++) {
-					const part = parts[i].trim();
-					const prev = i > 0 ? parts[i - 1].trim().split(":")[0] : null;
+		if (errors.length > 0) {
+			ctx.ui.notify("\u274c GSD include failed:\n" + errors.map((e) => "  \u2022 " + e).join("\n"), "error");
+			return { messages: [] }; // block LLM call
+		}
 
-					if (part.startsWith("tag:")) {
-						const tagName = part.slice(4);
-						const tagRe = new RegExp(
-							`<${tagName}>([\\s\\S]*?)</${tagName}>`,
-							"i",
-						);
-						const tagMatch = result.match(tagRe);
-						if (!tagMatch) {
-							errors.push(`Tag <${tagName}> not found in ${filePath}`);
-							result = "";
-							break;
-						}
-						result = tagMatch[1].trim();
+		// ── WXP post-processing: run after <gsd-include> resolution (WXP-14) ──
+		// Load global + project settings (HRN-06, HRN-07)
+		const extFile2 = typeof __filename !== "undefined" ? __filename : "";
+		const pkgRoot2 = join(dirname(extFile2), "..", "..");
+
+		type SettingsFile = {
+			shellAllowlist?: string[];
+			shellBanlist?: string[];
+			trustedPaths?: Array<{ position: "project" | "pkg" | "absolute"; path: string }>;
+			untrustedPaths?: Array<{ position: "project" | "pkg" | "absolute"; path: string }>;
+			shellTimeoutMs?: number;
+		};
+		const loadSettings = (settingsPath: string): SettingsFile => {
+			try {
+				if (existsSync(settingsPath)) {
+					return JSON.parse(readFileSync(settingsPath, "utf8")) as SettingsFile;
+				}
+			} catch { /* ignore */ }
+			return {};
+		};
+		const globalSettings = loadSettings(join(homedir(), ".gsd", "pi-gsd-settings.json"));
+		const projectSettings = loadSettings(join(ctx.cwd, ".pi", "gsd", "pi-gsd-settings.json"));
+		const mergedAllowlist = [
+			...DEFAULT_SHELL_ALLOWLIST,
+			...(globalSettings.shellAllowlist ?? []),
+			...(projectSettings.shellAllowlist ?? []),
+		];
+		const wxpSecurity: WxpSecurityConfig = {
+			trustedPaths: [
+				...(globalSettings.trustedPaths ?? []),
+				...(projectSettings.trustedPaths ?? []),
+				{ position: "pkg", path: ".gsd/harnesses/pi/get-shit-done" },
+				{ position: "project", path: ".pi/gsd" },
+			],
+			untrustedPaths: [
+				...(globalSettings.untrustedPaths ?? []),
+				...(projectSettings.untrustedPaths ?? []),
+			],
+			shellAllowlist: [...new Set(mergedAllowlist)],
+			shellBanlist: [
+				...(globalSettings.shellBanlist ?? []),
+				...(projectSettings.shellBanlist ?? []),
+			],
+			shellTimeoutMs: projectSettings.shellTimeoutMs ?? globalSettings.shellTimeoutMs ?? 30_000,
+		};
 
-					} else if (part.startsWith("heading:")) {
-						const headingText = part.slice(8);
-						const headingRe = new RegExp(
-							`(^|\\n)(#{1,6})\\s+${headingText.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&")}\\s*\\n`,
-						);
-						const hMatch = result.match(headingRe);
-						if (!hMatch) {
-							errors.push(`Heading \"${headingText}\" not found in ${filePath}`);
-							result = "";
-							break;
-						}
-						const level = hMatch[2].length;
-						const startIdx = (hMatch.index ?? 0) + hMatch[0].length;
-						const nextHeading = result.slice(startIdx).search(
-							new RegExp(`\\n#{1,${level}}\\s`),
-						);
-						result = nextHeading === -1
-							? result.slice(startIdx).trim()
-							: result.slice(startIdx, startIdx + nextHeading).trim();
-
-					} else if (part.startsWith("lines:")) {
-						const rangeMatch = part.match(/^lines:(\d+)-(\d+)$/);
-						if (!rangeMatch) {
-							errors.push(`Invalid lines selector: ${part}`);
-							result = "";
-							break;
-						}
-						const start = parseInt(rangeMatch[1], 10) - 1;
-						const end = parseInt(rangeMatch[2], 10);
-						result = result.split("\n").slice(start, end).join("\n");
-
-					} else {
-						errors.push(`Unknown selector: ${part}`);
-						result = "";
-						break;
+		try {
+			for (const msg of messages) {
+				if (msg.role !== "user") continue;
+				if (typeof msg.content === "string") {
+					if (!msg.content.includes("<gsd-")) continue;
+					const virtualPath = join(ctx.cwd, ".pi", "gsd", "workflows", "_message.md");
+					const rawArgs = extractRawArguments(msg.content);
+					msg.content = processWxpTrustedContent(msg.content, virtualPath, wxpSecurity, ctx.cwd, pkgRoot2, rawArgs, (m, lv) => ctx.ui.notify(m, lv === "error" ? "error" : "info"));
+				} else if (Array.isArray(msg.content)) {
+					for (const block of msg.content) {
+						if (block.type !== "text" || !block.text) continue;
+						if (!block.text.includes("<gsd-")) continue;
+						const virtualPath = join(ctx.cwd, ".pi", "gsd", "workflows", "_message.md");
+						const rawArgs = extractRawArguments(block.text);
+						block.text = processWxpTrustedContent(block.text, virtualPath, wxpSecurity, ctx.cwd, pkgRoot2, rawArgs, (m, lv) => ctx.ui.notify(m, lv === "error" ? "error" : "info"));
 					}
 				}
-				if (result === "") continue; // error already logged
 			}
-
-			transformed = transformed.replace(fullMatch, result);
-		}
-
-		if (errors.length > 0) {
-			ctx.ui.notify("\u274c GSD include failed:\n" + errors.map((e) => "  \u2022 " + e).join("\n"),
-				"error",
-			);
-			return { action: "handled" };
+		} catch (wxpErr) {
+			if (wxpErr instanceof WxpProcessingError) {
+				ctx.ui.notify(wxpErr.message, "error");
+				return { messages: [] }; // WXP-09: no partial content reaches LLM
+			}
+			// Non-WXP error: log but don't block
+			const errMsg = wxpErr instanceof Error ? wxpErr.message : String(wxpErr);
+			ctx.ui.notify(`GSD WXP: unexpected context error: ${errMsg}`, "info");
 		}
 
-		return { action: "transform", text: transformed };
+		return { messages };
 	});
 
 	// ── session_start: GSD update check ──────────────────────────────────────
 	pi.on("session_start", async (_event, ctx) => {
-		// Ensure harness files are reachable via .pi/gsd/ symlink
-		ensureHarnessSymlink(ctx.cwd);
-
+		// Copy-on-first-run harness distribution (HRN-01, HRN-03)
+		try {
+			const extFile = typeof __filename !== "undefined" ? __filename : "";
+			const pkgRoot = join(dirname(extFile), "..", "..");
+			const pkgHarness = join(pkgRoot, ".gsd", "harnesses", "pi", "get-shit-done");
+			const projectHarness = join(ctx.cwd, ".pi", "gsd");
+			if (existsSync(pkgHarness)) {
+				const { symlinksReplaced } = copyHarness(pkgHarness, projectHarness);
+				if (symlinksReplaced > 0) {
+					ctx.ui.notify(
+						`ℹ️ GSD: Replaced ${symlinksReplaced} symlink(s) in .pi/gsd/ with real file copies.`,
+						"info",
+					);
+				}
 
+				// Version-aware update detection (HRN-02)
+				try {
+					const pkgJsonPath = join(pkgRoot, "package.json");
+					if (existsSync(pkgJsonPath)) {
+						const pkgVersion = (JSON.parse(readFileSync(pkgJsonPath, "utf8")) as { version?: string }).version ?? "0.0.0";
+						const outdated: string[] = [];
+						// Check a sample of key workflow files for version drift
+						const sampleFiles = ["workflows/execute-phase.md", "workflows/plan-phase.md"];
+						for (const rel of sampleFiles) {
+							const projFile = join(projectHarness, rel);
+							if (!existsSync(projFile)) continue;
+							const content = readFileSync(projFile, "utf8");
+							const vtag = readWorkflowVersionTag(content);
+							if (!vtag || vtag.doNotUpdate) continue;
+							if (vtag.version !== pkgVersion) outdated.push(rel);
+						}
+						if (outdated.length > 0) {
+							ctx.ui.notify(
+								`ℹ️ GSD harness update available (package v${pkgVersion}).\n` +
+								`Outdated files: ${outdated.join(", ")}\n` +
+								`Run: pi-gsd-tools harness update [y|n|pick|diff]`,
+								"info",
+							);
+						}
+					}
+				} catch { /* silent */ }
+			}
+		} catch { /* silent */ }
 		try {
 			const cacheDir = join(homedir(), ".pi", "cache");
 			const cacheFile = join(cacheDir, "gsd-update-check.json");

package/.gsd/harnesses/pi/get-shit-done/workflows/add-phase.md

@@ -1,10 +1,68 @@
-<purpose>
-Add a new integer phase to the end of the current milestone in the roadmap. Automatically calculates next phase number, creates phase directory, and updates roadmap structure.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
+<gsd-version v="1.12.4" />
+
+<gsd-arguments>
+  <settings>
+    <keep-extra-args />
+  </settings>
+  <arg name="description" type="string" optional />
+</gsd-arguments>
+
+<gsd-execute>
+  <shell command="pi-gsd-tools">
+    <args>
+      <arg string="init" />
+      <arg string="phase-op" />
+      <arg string="0" />
+    </args>
+    <outs>
+      <out type="string" name="init" />
+    </outs>
+  </shell>
+  <if>
+    <condition>
+      <starts-with>
+        <left name="init" />
+        <right type="string" value="@file:" />
+      </starts-with>
+    </condition>
+    <then>
+      <string-op op="split">
+        <args>
+          <arg name="init" />
+          <arg type="string" value="@file:" />
+        </args>
+        <outs>
+          <out type="string" name="init-file" />
+        </outs>
+      </string-op>
+      <shell command="cat">
+        <args>
+          <arg name="init-file" wrap='"' />
+        </args>
+        <outs>
+          <out type="string" name="init" />
+        </outs>
+      </shell>
+    </then>
+  </if>
+  <shell command="pi-gsd-tools">
+    <args>
+      <arg string="state" />
+      <arg string="json" />
+      <arg string="--raw" />
+    </args>
+    <outs>
+      <out type="string" name="state" />
+    </outs>
+  </shell>
+</gsd-execute>
+
+## Context (pre-injected by WXP)
+
+**Description:** <gsd-paste name="description" />
+
+**Project State:**
+<gsd-paste name="state" />
 
 <process>
 
@@ -28,10 +86,7 @@ Exit.
 <step name="init_context">
 Load phase operation context:
 
-```bash
-INIT=$(pi-gsd-tools init phase-op "0")
-if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-```
+<!-- Context pre-injected above via WXP — variables available via <gsd-paste name="..."> -->
 
 Check `roadmap_exists` from init JSON. If false:
 ```