gentle-pi 0.1.18 → 0.1.19

package/assets/agents/sdd-init.md

@@ -1,6 +1,7 @@
 ---
 name: sdd-init
 description: Initialize project SDD context, testing capabilities, and skill registry.
+model: openai-codex/gpt-5.3-codex
 tools: read, grep, glob, write, bash
 inheritProjectContext: true
 ---
@@ -8,7 +9,8 @@ inheritProjectContext: true
 You are the SDD init executor for Gentle AI.
 
 - Inspect the project stack, test runner, conventions, and existing docs.
-- Create or update `openspec/config.yaml` with project context, `strict_tdd`, phase rules, and testing runner details.
+- If `openspec/config.yaml` is missing, create it automatically with project context, `strict_tdd`, phase rules, and testing runner details.
+- If `openspec/config.yaml` already exists, read it, summarize the current SDD/testing configuration, and do not block the caller. Update only safe derived context when explicitly necessary; never destructively rewrite user-maintained SDD configuration.
 - Ensure `.atl/skill-registry.md` exists when skill registry data is available, or report that it is missing.
 - Do NOT launch child subagents. Parent/orchestrator owns delegation.
 - Return the standard phase envelope with status, executive_summary, artifacts, next_recommended, risks, and skill_resolution.

package/assets/chains/sdd-full.chain.md

@@ -4,13 +4,15 @@ description: Run the full SDD lifecycle for a change when explicitly approved.
 ---
 
 ## sdd-init
+
 output: init.md
 outputMode: file-only
 progress: true
 
-Initialize or refresh SDD context for {task}. Detect project context, testing capabilities, strict TDD setting, and skill registry availability.
+Initialize SDD context for {task} before any planning or implementation. If `openspec/config.yaml` is missing, inspect the project and create it automatically. If it already exists, read it, refresh only safe derived context when appropriate, and report the current SDD/testing configuration without blocking the chain.
 
 ## sdd-explore
+
 reads: init.md
 output: exploration.md
 outputMode: file-only
@@ -19,6 +21,7 @@ progress: true
 Explore {task}. Identify scope, risks, dependencies, prior art, and whether the change should proceed into proposal.
 
 ## sdd-proposal
+
 reads: exploration.md
 output: proposal.md
 outputMode: file-only
@@ -27,6 +30,7 @@ progress: true
 Create or update the OpenSpec proposal for {task} using the exploration notes and the previous step output.
 
 ## sdd-spec
+
 reads: proposal.md
 output: spec.md
 outputMode: file-only
@@ -35,6 +39,7 @@ progress: true
 Write delta specs for {task} from the approved proposal. Preserve RFC 2119 requirements and Given/When/Then scenarios.
 
 ## sdd-design
+
 reads: proposal.md+spec.md
 output: design.md
 outputMode: file-only
@@ -43,6 +48,7 @@ progress: true
 Design the technical approach for {task} using the proposal, specs, and previous outputs. Call out review and judgment risks.
 
 ## sdd-tasks
+
 reads: proposal.md+spec.md+design.md
 output: tasks.md
 outputMode: file-only
@@ -51,6 +57,7 @@ progress: true
 Create strict-TDD, reviewable implementation tasks for {task}. Include the required Review Workload Forecast guard lines and PR split recommendation.
 
 ## sdd-apply
+
 reads: proposal.md+spec.md+design.md+tasks.md
 output: apply-progress.md
 outputMode: file-only
@@ -59,6 +66,7 @@ progress: true
 Implement only approved tasks for {task}; enforce strict TDD when active and stop before writing if workload decisions are unresolved. Update OpenSpec tasks and apply-progress with evidence.
 
 ## sdd-verify
+
 reads: proposal.md+spec.md+design.md+tasks.md+apply-progress.md
 output: verify-report.md
 outputMode: file-only
@@ -67,6 +75,7 @@ progress: true
 Verify {task} against specs, design, tasks, implementation, apply-progress, strict TDD evidence, assertion quality, and review workload boundaries.
 
 ## sdd-archive
+
 reads: verify-report.md
 output: archive-report.md
 outputMode: file-only

package/assets/chains/sdd-plan.chain.md

@@ -3,7 +3,17 @@ name: sdd-plan
 description: Plan an SDD change through proposal, spec, design, and tasks.
 ---
 
+## sdd-init
+
+output: init.md
+outputMode: file-only
+progress: true
+
+Initialize SDD context for {task} before planning. If `openspec/config.yaml` is missing, inspect the project and create it automatically. If it already exists, read it and report the current SDD/testing configuration without blocking the chain.
+
 ## sdd-proposal
+
+reads: init.md
 output: proposal.md
 outputMode: file-only
 progress: true
@@ -11,6 +21,7 @@ progress: true
 Create or update the OpenSpec proposal for {task}. Use prior exploration if it is available in the project artifacts.
 
 ## sdd-spec
+
 reads: proposal.md
 output: spec.md
 outputMode: file-only
@@ -19,6 +30,7 @@ progress: true
 Write delta specs for {task} using the proposal and previous output. Keep requirements and scenarios acceptance-focused.
 
 ## sdd-design
+
 reads: proposal.md+spec.md
 output: design.md
 outputMode: file-only
@@ -27,6 +39,7 @@ progress: true
 Design the technical approach for {task}. Preserve native SDD orchestration intent and identify review/judgment risks.
 
 ## sdd-tasks
+
 reads: proposal.md+spec.md+design.md
 output: tasks.md
 outputMode: file-only

package/assets/chains/sdd-verify.chain.md

@@ -3,7 +3,17 @@ name: sdd-verify
 description: Apply, verify, and optionally archive an already planned SDD change.
 ---
 
+## sdd-init
+
+output: init.md
+outputMode: file-only
+progress: true
+
+Initialize SDD context for {task} before apply/verify. If `openspec/config.yaml` is missing, inspect the project and create it automatically. If it already exists, read it and report the current SDD/testing configuration without blocking the chain.
+
 ## sdd-apply
+
+reads: init.md
 output: apply-progress.md
 outputMode: file-only
 progress: true
@@ -11,7 +21,8 @@ progress: true
 Implement pending approved tasks for {task}; update OpenSpec tasks and apply-progress with strict TDD evidence.
 
 ## sdd-verify
-reads: apply-progress.md
+
+reads: init.md+apply-progress.md
 output: verify-report.md
 outputMode: file-only
 progress: true
@@ -19,6 +30,7 @@ progress: true
 Run focused and full verification for {task} using the apply-progress and project artifacts. Include review/judgment blockers.
 
 ## sdd-archive
+
 reads: verify-report.md
 output: archive-report.md
 outputMode: file-only

package/extensions/sdd-init.ts

@@ -1,8 +1,62 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+type ExtensionAPI = any;
 
 const CONFIG_REL_PATH = "openspec/config.yaml";
+const MAX_SCAN_FILES = 5_000;
+const IGNORED_DIRS = new Set([
+	".git",
+	".hg",
+	".svn",
+	"node_modules",
+	"vendor",
+	"dist",
+	"build",
+	"target",
+	"coverage",
+	".next",
+	".nuxt",
+	".turbo",
+	".cache",
+	"__pycache__",
+]);
+
+interface PackageJson {
+	name?: string;
+	type?: string;
+	scripts?: Record<string, string>;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+	peerDependencies?: Record<string, string>;
+}
+
+interface Detection {
+	projectName: string;
+	stack: string[];
+	packageManager?: string;
+	markers: string[];
+	testCommand?: string;
+	testFramework?: string;
+	coverageCommand?: string;
+	lintCommand?: string;
+	typecheckCommand?: string;
+	formatCommand?: string;
+	testLayers: {
+		unit?: string;
+		integration?: string;
+		e2e?: string;
+	};
+}
+
+function yamlString(value: string): string {
+	return JSON.stringify(value);
+}
 
 function escapeBlockScalar(value: string): string {
 	return value
@@ -11,26 +65,315 @@ function escapeBlockScalar(value: string): string {
 		.join("\n");
 }
 
-function renderConfig(strictTdd: boolean, testCommand: string, context: string): string {
+function readJson<T>(path: string): T | undefined {
+	try {
+		return JSON.parse(readFileSync(path, "utf8")) as T;
+	} catch {
+		return undefined;
+	}
+}
+
+function hasFile(cwd: string, rel: string): boolean {
+	return existsSync(join(cwd, rel));
+}
+
+function walkProject(cwd: string): string[] {
+	const out: string[] = [];
+	const stack = [cwd];
+	while (stack.length > 0 && out.length < MAX_SCAN_FILES) {
+		const dir = stack.pop()!;
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (out.length >= MAX_SCAN_FILES) break;
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(entry.name)) stack.push(join(dir, entry.name));
+				continue;
+			}
+			if (entry.isFile()) out.push(join(dir, entry.name).slice(cwd.length + 1));
+		}
+	}
+	return out.sort();
+}
+
+function deps(pkg: PackageJson | undefined): Set<string> {
+	return new Set([
+		...Object.keys(pkg?.dependencies ?? {}),
+		...Object.keys(pkg?.devDependencies ?? {}),
+		...Object.keys(pkg?.peerDependencies ?? {}),
+	]);
+}
+
+function detectPackageManager(cwd: string): string | undefined {
+	if (hasFile(cwd, "pnpm-lock.yaml")) return "pnpm";
+	if (hasFile(cwd, "yarn.lock")) return "yarn";
+	if (hasFile(cwd, "bun.lockb") || hasFile(cwd, "bun.lock")) return "bun";
+	if (hasFile(cwd, "package-lock.json")) return "npm";
+	if (hasFile(cwd, "package.json")) return "npm";
+	return undefined;
+}
+
+function runScript(pm: string | undefined, script: string): string {
+	if (pm === "yarn") return `yarn ${script}`;
+	if (pm === "bun") return `bun run ${script}`;
+	return `${pm ?? "npm"} run ${script}`;
+}
+
+function scriptCommand(
+	pm: string | undefined,
+	scripts: Record<string, string> | undefined,
+	candidates: string[],
+): string | undefined {
+	if (!scripts) return undefined;
+	for (const name of candidates) {
+		if (scripts[name])
+			return name === "test" && pm !== "bun"
+				? `${pm ?? "npm"} test`
+				: runScript(pm, name);
+	}
+	return undefined;
+}
+
+function detectNode(cwd: string, files: string[], detection: Detection): void {
+	const pkg = readJson<PackageJson>(join(cwd, "package.json"));
+	if (
+		!pkg &&
+		!files.some(
+			(f) =>
+				f.endsWith(".ts") ||
+				f.endsWith(".tsx") ||
+				f.endsWith(".js") ||
+				f.endsWith(".jsx"),
+		)
+	)
+		return;
+	const pm = detectPackageManager(cwd);
+	detection.packageManager = pm;
+	detection.stack.push(
+		pkg?.type === "module" ? "Node.js/TypeScript ESM" : "Node.js/TypeScript",
+	);
+	if (pkg?.name) detection.projectName = pkg.name;
+	if (hasFile(cwd, "package.json")) detection.markers.push("package.json");
+	if (hasFile(cwd, "tsconfig.json")) detection.markers.push("tsconfig.json");
+	if (pm) detection.markers.push(`${pm} package manager`);
+
+	const allDeps = deps(pkg);
+	if (allDeps.has("react")) detection.stack.push("React");
+	if (allDeps.has("next")) detection.stack.push("Next.js");
+	if (allDeps.has("vue")) detection.stack.push("Vue");
+	if (allDeps.has("svelte")) detection.stack.push("Svelte");
+	if (allDeps.has("@earendil-works/pi-coding-agent"))
+		detection.stack.push("Pi extension package");
+
+	detection.testCommand = scriptCommand(pm, pkg?.scripts, [
+		"test",
+		"vitest",
+		"jest",
+		"unit",
+	]);
+	if (!detection.testCommand) {
+		if (
+			allDeps.has("vitest") ||
+			files.some((f) => /^vitest\.config\./.test(basename(f)))
+		)
+			detection.testCommand = runScript(pm, "vitest");
+		else if (
+			allDeps.has("jest") ||
+			files.some((f) => /^jest\.config\./.test(basename(f)))
+		)
+			detection.testCommand = runScript(pm, "jest");
+	}
+	if (allDeps.has("vitest")) detection.testFramework = "Vitest";
+	else if (allDeps.has("jest")) detection.testFramework = "Jest";
+	else if (detection.testCommand) detection.testFramework = "package script";
+
+	detection.coverageCommand = scriptCommand(pm, pkg?.scripts, [
+		"coverage",
+		"test:coverage",
+	]);
+	detection.lintCommand = scriptCommand(pm, pkg?.scripts, [
+		"lint",
+		"check:lint",
+	]);
+	detection.typecheckCommand = scriptCommand(pm, pkg?.scripts, [
+		"typecheck",
+		"type-check",
+		"check:types",
+	]);
+	detection.formatCommand = scriptCommand(pm, pkg?.scripts, [
+		"format",
+		"fmt",
+		"prettier",
+	]);
+
+	if (detection.testFramework)
+		detection.testLayers.unit = detection.testFramework;
+	if (allDeps.has("@testing-library/react") || allDeps.has("supertest"))
+		detection.testLayers.integration = "Testing Library / Supertest";
+	if (allDeps.has("playwright") || allDeps.has("@playwright/test"))
+		detection.testLayers.e2e = "Playwright";
+	else if (allDeps.has("cypress")) detection.testLayers.e2e = "Cypress";
+}
+
+function detectGo(cwd: string, files: string[], detection: Detection): void {
+	if (!hasFile(cwd, "go.mod")) return;
+	detection.stack.push("Go");
+	detection.markers.push("go.mod");
+	if (!detection.testCommand) detection.testCommand = "go test ./...";
+	if (!detection.testFramework) detection.testFramework = "go test";
+	detection.testLayers.unit ??= "go test";
+	if (files.some((f) => f.endsWith("_test.go")))
+		detection.testLayers.integration ??= "Go integration tests where present";
+	detection.coverageCommand ??= "go test -cover ./...";
+}
+
+function detectRust(cwd: string, detection: Detection): void {
+	if (!hasFile(cwd, "Cargo.toml")) return;
+	detection.stack.push("Rust");
+	detection.markers.push("Cargo.toml");
+	detection.testCommand ??= "cargo test";
+	detection.testFramework ??= "cargo test";
+	detection.testLayers.unit ??= "cargo test";
+}
+
+function detectPython(
+	cwd: string,
+	files: string[],
+	detection: Detection,
+): void {
+	const hasPython =
+		hasFile(cwd, "pyproject.toml") ||
+		hasFile(cwd, "requirements.txt") ||
+		hasFile(cwd, "pytest.ini") ||
+		files.some((f) => f.endsWith(".py"));
+	if (!hasPython) return;
+	detection.stack.push("Python");
+	for (const marker of ["pyproject.toml", "requirements.txt", "pytest.ini"]) {
+		if (hasFile(cwd, marker)) detection.markers.push(marker);
+	}
+	if (
+		!detection.testCommand &&
+		(hasFile(cwd, "pytest.ini") ||
+			files.some((f) => f.startsWith("tests/") || f.endsWith("_test.py")))
+	) {
+		detection.testCommand = "pytest";
+		detection.testFramework = "pytest";
+		detection.testLayers.unit = "pytest";
+	}
+}
+
+function detectMakefile(cwd: string, detection: Detection): void {
+	const makefile = ["Makefile", "makefile"].find((f) => hasFile(cwd, f));
+	if (!makefile) return;
+	detection.markers.push(makefile);
+	let content = "";
+	try {
+		content = readFileSync(join(cwd, makefile), "utf8");
+	} catch {
+		return;
+	}
+	if (!detection.testCommand && /^test:/m.test(content))
+		detection.testCommand = "make test";
+	if (!detection.lintCommand && /^lint:/m.test(content))
+		detection.lintCommand = "make lint";
+	if (!detection.formatCommand && /^(fmt|format):/m.test(content))
+		detection.formatCommand = /^fmt:/m.test(content)
+			? "make fmt"
+			: "make format";
+}
+
+function detectProject(cwd: string): Detection {
+	const files = walkProject(cwd);
+	const detection: Detection = {
+		projectName: basename(cwd),
+		stack: [],
+		markers: [],
+		testLayers: {},
+	};
+	detectNode(cwd, files, detection);
+	detectGo(cwd, files, detection);
+	detectRust(cwd, detection);
+	detectPython(cwd, files, detection);
+	detectMakefile(cwd, detection);
+	if (hasFile(cwd, ".github/workflows"))
+		detection.markers.push("GitHub Actions");
+	detection.stack = [...new Set(detection.stack)];
+	detection.markers = [...new Set(detection.markers)];
+	return detection;
+}
+
+function renderContext(detection: Detection): string {
+	const lines = [
+		`${detection.projectName} is a ${detection.stack.length > 0 ? detection.stack.join(", ") : "software"} project.`,
+		`Detected markers: ${detection.markers.length > 0 ? detection.markers.join(", ") : "none"}.`,
+	];
+	if (detection.packageManager)
+		lines.push(`Package manager: ${detection.packageManager}.`);
+	if (detection.testCommand)
+		lines.push(`Primary test command: ${detection.testCommand}.`);
+	else
+		lines.push(
+			"No reliable test runner was detected; verify testing manually before enabling strict TDD.",
+		);
+	return lines.join("\n");
+}
+
+function renderConfig(detection: Detection): string {
+	const strictTdd = Boolean(detection.testCommand);
+	const testCommand = detection.testCommand ?? "";
+	const today = new Date().toISOString().slice(0, 10);
+	const context = renderContext(detection);
 	const lines = [
 		`strict_tdd: ${strictTdd}`,
 		"context: |",
-		escapeBlockScalar(context.trimEnd()),
+		escapeBlockScalar(context),
 		"rules:",
+		"  proposal:",
+		"    require_problem_statement: true",
+		"  spec:",
+		"    require_acceptance_criteria: true",
+		"  design:",
+		"    require_tradeoffs: true",
+		"  tasks:",
+		"    protect_review_workload: true",
 		"  apply:",
-		`    test_command: ${testCommand}`,
+		`    test_command: ${yamlString(testCommand)}`,
+		"  verify:",
+		`    test_command: ${yamlString(testCommand)}`,
 		"testing:",
+		`  detected: ${yamlString(today)}`,
 		"  runner:",
-		`    command: ${testCommand}`,
+		`    command: ${yamlString(testCommand)}`,
+		`    framework: ${yamlString(detection.testFramework ?? "")}`,
+		"  layers:",
+		`    unit: ${yamlString(detection.testLayers.unit ?? "")}`,
+		`    integration: ${yamlString(detection.testLayers.integration ?? "")}`,
+		`    e2e: ${yamlString(detection.testLayers.e2e ?? "")}`,
+		"  coverage:",
+		`    command: ${yamlString(detection.coverageCommand ?? "")}`,
+		"quality:",
+		`  lint: ${yamlString(detection.lintCommand ?? "")}`,
+		`  typecheck: ${yamlString(detection.typecheckCommand ?? "")}`,
+		`  format: ${yamlString(detection.formatCommand ?? "")}`,
 		"",
 	];
 	return lines.join("\n");
 }
 
+function ensureOpenSpecDirs(cwd: string): void {
+	mkdirSync(join(cwd, "openspec", "specs"), { recursive: true });
+	mkdirSync(join(cwd, "openspec", "changes", "archive"), { recursive: true });
+}
+
 export default function (pi: ExtensionAPI) {
 	pi.registerCommand("sdd-init", {
-		description: "Bootstrap openspec/config.yaml for SDD workflow (one-time per project).",
-		handler: async (_args, ctx) => {
+		description:
+			"Auto-detect project stack and bootstrap openspec/config.yaml for SDD.",
+		handler: async (_args: unknown, ctx: any) => {
 			const configPath = join(ctx.cwd, CONFIG_REL_PATH);
 			if (existsSync(configPath)) {
 				ctx.ui.notify(
@@ -40,42 +383,16 @@ export default function (pi: ExtensionAPI) {
 				return;
 			}
 
-			const TDD_YES = "Yes — tests must run before each change";
-			const TDD_NO = "No — TDD is opt-in per task";
-			const TDD_CANCEL = "Cancel";
-			const tddChoice = await ctx.ui.select("Enable strict TDD for this project?", [
-				TDD_YES,
-				TDD_NO,
-				TDD_CANCEL,
-			]);
-			if (!tddChoice || tddChoice === TDD_CANCEL) {
-				ctx.ui.notify("sdd-init cancelled.", "info");
-				return;
-			}
-			const strictTdd = tddChoice === TDD_YES;
-
-			const testCommand = await ctx.ui.input(
-				"Test command",
-				"e.g. npm test, pnpm vitest, cargo test",
-			);
-			if (!testCommand) {
-				ctx.ui.notify("sdd-init cancelled (no test command).", "info");
-				return;
-			}
-
-			const context = await ctx.ui.input(
-				"Project context (one paragraph)",
-				"Describe the project, stack, and constraints.",
-			);
-			if (!context) {
-				ctx.ui.notify("sdd-init cancelled (no context).", "info");
-				return;
-			}
-
+			const detection = detectProject(ctx.cwd);
+			ensureOpenSpecDirs(ctx.cwd);
 			mkdirSync(dirname(configPath), { recursive: true });
-			writeFileSync(configPath, renderConfig(strictTdd, testCommand.trim(), context));
+			writeFileSync(configPath, renderConfig(detection));
+
+			const testSummary = detection.testCommand
+				? `strict TDD enabled with \`${detection.testCommand}\``
+				: "strict TDD disabled because no test runner was detected";
 			ctx.ui.notify(
-				`Wrote ${CONFIG_REL_PATH}. Run /skill-registry:refresh once skills with '## Compact Rules' are available.`,
+				`Wrote ${CONFIG_REL_PATH}: detected ${detection.stack.join(", ") || "project"}; ${testSummary}.`,
 				"info",
 			);
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
   "license": "MIT",
   "type": "module",