pi-harness-runtime 1.1.0 → 1.1.2

package/scripts/release/adapters/node-workspace.ts

@@ -0,0 +1,230 @@
+/**
+ * Node.js / npm Workspace adapter.
+ *
+ * Handles:
+ * - root package.json
+ * - workspace package.json files (packages/*)
+ *
+ * Source of truth: root package.json version
+ */
+
+import type {
+	AdapterContext,
+	BumpResult,
+	ReleaseAdapter,
+	VerificationResult,
+	VersionManifest,
+} from "./base.ts";
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "path";
+
+const ROOT_PKG = "package.json";
+const WORKSPACE_GLOB = "packages/*";
+
+function getWorkspaceDirs(repoRoot: string): string[] {
+	const dirs: string[] = [];
+	const globBase = resolve(repoRoot, WORKSPACE_GLOB.replace(/\/\*$/, ""));
+
+	let entries: string[];
+	try {
+		entries = readdirSync(globBase);
+	} catch {
+		return dirs;
+	}
+
+	for (const entry of entries) {
+		const pkgPath = join(globBase, entry, ROOT_PKG);
+		if (existsSync(pkgPath)) {
+			dirs.push(resolve(globBase, entry));
+		}
+	}
+	return dirs;
+}
+
+async function readManifest(
+	ctx: AdapterContext,
+	relPath: string,
+): Promise<VersionManifest | null> {
+	const absPath = join(ctx.repoRoot, relPath);
+	if (!existsSync(absPath)) return null;
+
+	let raw: string;
+	try {
+		raw = await readFile(absPath, "utf-8");
+	} catch {
+		return null;
+	}
+
+	let pkg: Record<string, unknown>;
+	try {
+		pkg = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+
+	const version = typeof pkg.version === "string" ? pkg.version : "";
+	return { path: relPath, version, content: raw };
+}
+
+async function writeManifest(
+	ctx: AdapterContext,
+	manifest: VersionManifest,
+	newVersion: string,
+): Promise<void> {
+	if (ctx.dryRun) return;
+
+	const absPath = join(ctx.repoRoot, manifest.path);
+	let pkg: Record<string, unknown>;
+	try {
+		pkg = JSON.parse(manifest.content);
+	} catch {
+		return;
+	}
+
+	pkg.version = newVersion;
+
+	// Re-serialize: parse→stringify→parse→stringify collapses duplicate keys
+	// (duplicate "version" keys are valid JSON but break bun install)
+	let serialized: string;
+	try {
+		serialized = JSON.stringify(JSON.parse(JSON.stringify(pkg)), null, 2);
+	} catch {
+		serialized = JSON.stringify(pkg, null, 2);
+	}
+	await writeFile(absPath, `${serialized}\n`);
+}
+
+export const nodeWorkspaceAdapter: ReleaseAdapter = {
+	id: "node-workspace",
+	name: "Node.js / npm Workspace",
+
+	detect(ctx: AdapterContext): number {
+		const rootPkg = join(ctx.repoRoot, "package.json");
+		if (!existsSync(rootPkg)) return 0;
+
+		// Must have workspaces field
+		try {
+			const raw = JSON.parse(
+				readFileSync(rootPkg, "utf-8") as unknown as string,
+			);
+			if (raw.workspaces) return 0.9;
+		} catch {
+			// ignore
+		}
+
+		// Plain Node repo (no workspaces) still qualifies
+		return 0.6;
+	},
+
+	async readManifests(ctx: AdapterContext): Promise<VersionManifest[]> {
+		const manifests: VersionManifest[] = [];
+
+		// Root package.json
+		const root = await readManifest(ctx, ROOT_PKG);
+		if (root) manifests.push(root);
+
+		// Workspace package.json files
+		const dirs = getWorkspaceDirs(ctx.repoRoot);
+		for (const dir of dirs) {
+			const relPath = dir.replace(ctx.repoRoot + "/", "");
+			const manifest = await readManifest(ctx, `${relPath}/${ROOT_PKG}`);
+			if (manifest) manifests.push(manifest);
+		}
+
+		return manifests;
+	},
+
+	async bump(
+		ctx: AdapterContext,
+		bumpType,
+		newVersion?: string,
+	): Promise<BumpResult> {
+		const manifests = await this.readManifests(ctx);
+		const root = manifests.find((m) => m.path === ROOT_PKG);
+		const rootVersion = root?.version ?? "0.0.0";
+
+		// Determine new version
+		let finalVersion: string;
+		if (newVersion) {
+			finalVersion = newVersion;
+		} else {
+			const parts = rootVersion.split("-")[0].split(".").map(Number);
+			const [major = 0, minor = 0, patch = 0] = parts;
+			switch (bumpType) {
+				case "major":
+					finalVersion = `${major + 1}.0.0`;
+					break;
+				case "minor":
+					finalVersion = `${major}.${minor + 1}.0`;
+					break;
+				case "prerelease":
+					finalVersion = `${rootVersion}`;
+					break;
+				default:
+					// patch
+					finalVersion = `${major}.${minor}.${patch + 1}`;
+			}
+		}
+
+		const actions: string[] = [];
+		const updated: VersionManifest[] = [];
+
+		// Update all manifests
+		for (const manifest of manifests) {
+			if (ctx.verbose) {
+				actions.push(
+					`Update ${manifest.path}: ${manifest.version} -> ${finalVersion}`,
+				);
+			}
+			await writeManifest(ctx, manifest, finalVersion);
+			updated.push({ ...manifest, version: finalVersion });
+		}
+
+		return { newVersion: finalVersion, updated, actions };
+	},
+
+	async verify(
+		ctx: AdapterContext,
+		expectedVersion: string,
+	): Promise<VerificationResult> {
+		const errors: string[] = [];
+		const warnings: string[] = [];
+
+		const manifests = await this.readManifests(ctx);
+		if (manifests.length === 0) {
+			errors.push("No package.json files found");
+			return { ok: false, errors, warnings };
+		}
+
+		const versions = manifests.map((m) => m.version);
+		const unique = [...new Set(versions)];
+
+		if (unique.length > 1) {
+			errors.push(
+				`Version mismatch across packages: ${JSON.stringify(
+					Object.fromEntries(manifests.map((m) => [m.path, m.version])),
+				)}`,
+			);
+		}
+
+		if (!expectedVersion && unique.length === 1) {
+			// All good — all versions match
+		} else if (
+			expectedVersion &&
+			unique.length === 1 &&
+			unique[0] !== expectedVersion
+		) {
+			errors.push(
+				`Version ${unique[0]} does not match expected ${expectedVersion}`,
+			);
+		}
+
+		return { ok: errors.length === 0, errors, warnings };
+	},
+
+	async getCanonicalVersion(ctx: AdapterContext): Promise<string | null> {
+		const root = await readManifest(ctx, ROOT_PKG);
+		return root?.version ?? null;
+	},
+};

package/scripts/release/adapters/python.ts

@@ -0,0 +1,236 @@
+/**
+ * Python adapter.
+ *
+ * Handles version synchronization for Python packages:
+ * - pyproject.toml (project.version field)
+ *
+ * Source of truth: pyproject.toml version field
+ */
+
+import type {
+	AdapterContext,
+	BumpResult,
+	ReleaseAdapter,
+	VerificationResult,
+	VersionManifest,
+} from "./base.ts";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "path";
+
+function parsePyprojectVersion(content: string): string | null {
+	// Try PEP 621 format: [project] ... version = "1.2.3"
+	let match = content.match(/^\[project\][\s\S]*?^\s*version\s*=\s*"([^"]+)"/m);
+	if (match) return match[1];
+
+	// Try poetry format: [tool.poetry] ... version = "1.2.3"
+	match = content.match(
+		/^\[tool\.poetry\][\s\S]*?^\s*version\s*=\s*"([^"]+)"/m,
+	);
+	if (match) return match[1];
+
+	// Try setup.cfg style: version = "1.2.3"
+	match = content.match(/^\s*version\s*=\s*"([^"]+)"/m);
+	if (match) return match[1];
+
+	return null;
+}
+
+function bumpVersion(
+	content: string,
+	newVersion: string,
+): { content: string; found: boolean } {
+	// Try PEP 621 first
+	let found = false;
+	let result = content.replace(
+		/^(\s*version\s*=\s*")([^"]+)(")/m,
+		(_m, before: string, _old: string, after: string) => {
+			found = true;
+			return `${before}${newVersion}${after}`;
+		},
+	);
+	if (found) return { content: result, found: true };
+
+	// Try poetry format
+	result = content.replace(
+		/^(\s*version\s*=\s*")([^"]+)(")/m,
+		(_m, before: string, _old: string, after: string) => {
+			found = true;
+			return `${before}${newVersion}${after}`;
+		},
+	);
+	if (found) return { content: result, found: true };
+
+	return { content, found: false };
+}
+
+export const pythonAdapter: ReleaseAdapter = {
+	id: "python",
+	name: "Python Package",
+
+	detect(ctx: AdapterContext): number {
+		const hasPyproject = existsSync(join(ctx.repoRoot, "pyproject.toml"));
+		const hasSetupPy = existsSync(join(ctx.repoRoot, "setup.py"));
+		const hasSetupCfg = existsSync(join(ctx.repoRoot, "setup.cfg"));
+
+		if (hasPyproject) return 0.95;
+		if (hasSetupPy || hasSetupCfg) return 0.85;
+		return 0;
+	},
+
+	async readManifests(ctx: AdapterContext): Promise<VersionManifest[]> {
+		const manifests: VersionManifest[] = [];
+
+		// pyproject.toml
+		const pyprojectPath = join(ctx.repoRoot, "pyproject.toml");
+		if (existsSync(pyprojectPath)) {
+			try {
+				const content = await readFile(pyprojectPath, "utf-8");
+				const version = parsePyprojectVersion(content);
+				if (version) {
+					manifests.push({
+						path: "pyproject.toml",
+						version,
+						content,
+					});
+				}
+			} catch {
+				// ignore
+			}
+		}
+
+		// setup.py (if it has a version= assignment)
+		const setupPyPath = join(ctx.repoRoot, "setup.py");
+		if (existsSync(setupPyPath)) {
+			try {
+				const content = await readFile(setupPyPath, "utf-8");
+				const match = content.match(/^\s*version\s*=\s*["']([^"']+)["']/m);
+				if (match) {
+					manifests.push({
+						path: "setup.py",
+						version: match[1],
+						content,
+					});
+				}
+			} catch {
+				// ignore
+			}
+		}
+
+		return manifests;
+	},
+
+	async bump(
+		ctx: AdapterContext,
+		bumpType: "patch" | "minor" | "major" | "prerelease",
+		newVersion?: string,
+	): Promise<BumpResult> {
+		const manifests = await this.readManifests(ctx);
+		const base = manifests[0]?.version ?? "0.1.0";
+
+		let finalVersion: string;
+		if (newVersion) {
+			finalVersion = newVersion;
+		} else {
+			const parts = base.split("-")[0].split(".").map(Number);
+			const [major = 0, minor = 0, patch = 0] = parts;
+			switch (bumpType) {
+				case "major":
+					finalVersion = `${major + 1}.0.0`;
+					break;
+				case "minor":
+					finalVersion = `${major}.${minor + 1}.0`;
+					break;
+				case "prerelease":
+					finalVersion = base;
+					break;
+				default:
+					finalVersion = `${major}.${minor}.${patch + 1}`;
+			}
+		}
+
+		const actions: string[] = [];
+		const updated: VersionManifest[] = [];
+
+		// pyproject.toml
+		const pyprojectPath = join(ctx.repoRoot, "pyproject.toml");
+		if (existsSync(pyprojectPath)) {
+			const absPath = join(ctx.repoRoot, "pyproject.toml");
+			let content: string;
+			try {
+				content = await readFile(absPath, "utf-8");
+			} catch {
+				content = "";
+			}
+
+			const { content: newContent, found } = bumpVersion(content, finalVersion);
+			if (found && !ctx.dryRun) {
+				await writeFile(absPath, newContent);
+			}
+			actions.push(
+				`${ctx.dryRun ? "[dry-run] " : ""}Update pyproject.toml: ${base} -> ${finalVersion}`,
+			);
+			updated.push({
+				path: "pyproject.toml",
+				version: finalVersion,
+				content: newContent,
+			});
+		}
+
+		return { newVersion: finalVersion, updated, actions };
+	},
+
+	async verify(
+		ctx: AdapterContext,
+		expectedVersion: string,
+	): Promise<VerificationResult> {
+		const errors: string[] = [];
+		const warnings: string[] = [];
+
+		const manifests = await this.readManifests(ctx);
+		if (manifests.length === 0) {
+			errors.push(
+				"No Python version manifests found (pyproject.toml, setup.py)",
+			);
+			return { ok: false, errors, warnings };
+		}
+
+		const versions = manifests.map((m) => m.version);
+		const unique = [...new Set(versions)];
+
+		if (unique.length > 1) {
+			errors.push(
+				`Version mismatch across Python manifests: ${JSON.stringify(
+					Object.fromEntries(manifests.map((m) => [m.path, m.version])),
+				)}`,
+			);
+		}
+
+		if (
+			expectedVersion &&
+			unique.length === 1 &&
+			unique[0] !== expectedVersion
+		) {
+			errors.push(
+				`Version ${unique[0]} does not match expected ${expectedVersion}`,
+			);
+		}
+
+		return { ok: errors.length === 0, errors, warnings };
+	},
+
+	async getCanonicalVersion(ctx: AdapterContext): Promise<string | null> {
+		// pyproject.toml is canonical if present
+		const pyprojectPath = join(ctx.repoRoot, "pyproject.toml");
+		if (existsSync(pyprojectPath)) {
+			try {
+				const content = await readFile(pyprojectPath, "utf-8");
+				return parsePyprojectVersion(content);
+			} catch {
+				return null;
+			}
+		}
+		const manifests = await this.readManifests(ctx);
+		return manifests[0]?.version ?? null;
+	},
+};

package/scripts/release/adapters/rust.ts

@@ -0,0 +1,129 @@
+/**
+ * Rust adapter.
+ *
+ * Handles version synchronization for Rust crates:
+ * - Cargo.toml (version field)
+ *
+ * Source of truth: Cargo.toml version field
+ */
+
+import type {
+	AdapterContext,
+	BumpResult,
+	ReleaseAdapter,
+	VerificationResult,
+	VersionManifest,
+} from "./base.ts";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "path";
+
+export const rustAdapter: ReleaseAdapter = {
+	id: "rust",
+	name: "Rust Crate",
+
+	detect(ctx: AdapterContext): number {
+		const hasRootCargo = existsSync(join(ctx.repoRoot, "Cargo.toml"));
+		const hasTauriCargo = existsSync(
+			join(ctx.repoRoot, "src-tauri", "Cargo.toml"),
+		);
+
+		// Root Cargo.toml without Tauri structure
+		if (hasRootCargo && !hasTauriCargo) return 0.95;
+		return 0;
+	},
+
+	async readManifests(ctx: AdapterContext): Promise<VersionManifest[]> {
+		const manifest: VersionManifest | null = await (async () => {
+			const path = join(ctx.repoRoot, "Cargo.toml");
+			if (!existsSync(path)) return null;
+			try {
+				const content = await readFile(path, "utf-8");
+				const match = content.match(/^\s*version\s*=\s*"([^"]+)"/m);
+				if (!match) return null;
+				return { path: "Cargo.toml", version: match[1], content };
+			} catch {
+				return null;
+			}
+		})();
+		return manifest ? [manifest] : [];
+	},
+
+	async bump(
+		ctx: AdapterContext,
+		bumpType: "patch" | "minor" | "major" | "prerelease",
+		newVersion?: string,
+	): Promise<BumpResult> {
+		const manifests = await this.readManifests(ctx);
+		const base = manifests[0]?.version ?? "0.1.0";
+
+		let finalVersion: string;
+		if (newVersion) {
+			finalVersion = newVersion;
+		} else {
+			const parts = base.split("-")[0].split(".").map(Number);
+			const [major = 0, minor = 0, patch = 0] = parts;
+			switch (bumpType) {
+				case "major":
+					finalVersion = `${major + 1}.0.0`;
+					break;
+				case "minor":
+					finalVersion = `${major}.${minor + 1}.0`;
+					break;
+				case "prerelease":
+					finalVersion = base;
+					break;
+				default:
+					finalVersion = `${major}.${minor}.${patch + 1}`;
+			}
+		}
+
+		const actions: string[] = [];
+		const updated: VersionManifest[] = [];
+
+		if (!ctx.dryRun && manifests.length > 0) {
+			const absPath = join(ctx.repoRoot, "Cargo.toml");
+			let content = manifests[0].content;
+			content = content.replace(
+				/^(\s*version\s*=\s*")([^"]+)(")/m,
+				`$1${finalVersion}$3`,
+			);
+			await writeFile(absPath, content);
+			actions.push(`Update Cargo.toml: ${base} -> ${finalVersion}`);
+		} else {
+			actions.push(
+				`[dry-run] Would update Cargo.toml: ${base} -> ${finalVersion}`,
+			);
+		}
+
+		updated.push({ path: "Cargo.toml", version: finalVersion, content: "" });
+		return { newVersion: finalVersion, updated, actions };
+	},
+
+	async verify(
+		ctx: AdapterContext,
+		expectedVersion: string,
+	): Promise<VerificationResult> {
+		const errors: string[] = [];
+		const warnings: string[] = [];
+
+		const manifests = await this.readManifests(ctx);
+		if (manifests.length === 0) {
+			errors.push("Cargo.toml not found or has no version field");
+			return { ok: false, errors, warnings };
+		}
+
+		if (expectedVersion && manifests[0].version !== expectedVersion) {
+			errors.push(
+				`Cargo.toml version ${manifests[0].version} does not match expected ${expectedVersion}`,
+			);
+		}
+
+		return { ok: errors.length === 0, errors, warnings };
+	},
+
+	async getCanonicalVersion(ctx: AdapterContext): Promise<string | null> {
+		const manifests = await this.readManifests(ctx);
+		return manifests[0]?.version ?? null;
+	},
+};