pi-harness-runtime 1.1.0 → 1.1.2

package/scripts/release/adapters/tauri.ts

@@ -0,0 +1,298 @@
+/**
+ * Tauri adapter.
+ *
+ * Handles version synchronization for Tauri desktop apps across:
+ * - package.json (npm frontend version)
+ * - src-tauri/Cargo.toml (Rust backend version)
+ * - src-tauri/tauri.conf.json (Tauri app version)
+ *
+ * Source of truth: whichever file has the version that was bumped,
+ * typically package.json. Other files are synchronized to match.
+ *
+ * Detection: repo has src-tauri/Cargo.toml AND src-tauri/tauri.conf.json
+ */
+
+import type {
+	AdapterContext,
+	BumpResult,
+	ReleaseAdapter,
+	VerificationResult,
+	VersionManifest,
+} from "./base.ts";
+import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "path";
+
+const MANIFESTS = [
+	"package.json",
+	"src-tauri/Cargo.toml",
+	"src-tauri/tauri.conf.json",
+] as const;
+
+type TauriManifest = (typeof MANIFESTS)[number];
+
+function parsePackageJson(content: string): string | null {
+	try {
+		const pkg = JSON.parse(content);
+		return typeof pkg.version === "string" ? pkg.version : null;
+	} catch {
+		return null;
+	}
+}
+
+function parseCargoToml(content: string): string | null {
+	// Cargo.toml version: version = "1.2.3"
+	const match = content.match(/^\s*version\s*=\s*"([^"]+)"/m);
+	return match ? match[1] : null;
+}
+
+function parseTauriConf(content: string): string | null {
+	try {
+		const conf = JSON.parse(content);
+		return typeof conf.version === "string" ? conf.version : null;
+	} catch {
+		// Try toml format
+		const match = content.match(/^\s*version\s*=\s*"([^"]+)"/m);
+		return match ? match[1] : null;
+	}
+}
+
+function parseVersion(path: TauriManifest, content: string): string | null {
+	switch (path) {
+		case "package.json":
+			return parsePackageJson(content);
+		case "src-tauri/Cargo.toml":
+			return parseCargoToml(content);
+		case "src-tauri/tauri.conf.json":
+			return parseTauriConf(content);
+	}
+}
+
+async function writePackageJson(
+	ctx: AdapterContext,
+	relPath: string,
+	version: string,
+): Promise<void> {
+	if (ctx.dryRun) return;
+	const { readFile, writeFile } = await import("node:fs/promises");
+	const absPath = join(ctx.repoRoot, relPath);
+	let pkg: Record<string, unknown>;
+	try {
+		pkg = JSON.parse(await readFile(absPath, "utf-8"));
+	} catch {
+		return;
+	}
+	pkg.version = version;
+	await writeFile(absPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+
+async function writeCargoToml(
+	ctx: AdapterContext,
+	relPath: string,
+	version: string,
+): Promise<void> {
+	if (ctx.dryRun) return;
+	const { readFile, writeFile } = await import("node:fs/promises");
+	const absPath = join(ctx.repoRoot, relPath);
+	let content: string;
+	try {
+		content = await readFile(absPath, "utf-8");
+	} catch {
+		return;
+	}
+	// Replace version = "x.y.z" with new version
+	content = content.replace(
+		/^(\s*version\s*=\s*")([^"]+)(")/m,
+		`$1${version}$3`,
+	);
+	await writeFile(absPath, content);
+}
+
+async function writeTauriConf(
+	ctx: AdapterContext,
+	relPath: string,
+	version: string,
+): Promise<void> {
+	if (ctx.dryRun) return;
+	const { readFile, writeFile } = await import("node:fs/promises");
+	const absPath = join(ctx.repoRoot, relPath);
+	let content: string;
+	try {
+		content = await readFile(absPath, "utf-8");
+	} catch {
+		return;
+	}
+
+	// Try JSON first
+	try {
+		const conf = JSON.parse(content);
+		conf.version = version;
+		await writeFile(absPath, JSON.stringify(conf, null, 2) + "\n");
+		return;
+	} catch {
+		// Not JSON, try TOML
+	}
+
+	// TOML format: version = "1.2.3"
+	content = content.replace(
+		/^(\s*version\s*=\s*")([^"]+)(")/m,
+		`$1${version}$3`,
+	);
+	await writeFile(absPath, content);
+}
+
+async function writeManifest(
+	ctx: AdapterContext,
+	relPath: string,
+	version: string,
+): Promise<void> {
+	if (relPath === "package.json") {
+		await writePackageJson(ctx, relPath, version);
+	} else if (relPath === "src-tauri/Cargo.toml") {
+		await writeCargoToml(ctx, relPath, version);
+	} else if (relPath === "src-tauri/tauri.conf.json") {
+		await writeTauriConf(ctx, relPath, version);
+	}
+}
+
+export const tauriAdapter: ReleaseAdapter = {
+	id: "tauri",
+	name: "Tauri Desktop App",
+
+	detect(ctx: AdapterContext): number {
+		const hasCargo = existsSync(join(ctx.repoRoot, "src-tauri", "Cargo.toml"));
+		const hasTauriConf = existsSync(
+			join(ctx.repoRoot, "src-tauri", "tauri.conf.json"),
+		);
+		const hasPackageJson = existsSync(join(ctx.repoRoot, "package.json"));
+
+		if (hasCargo && hasTauriConf && hasPackageJson) return 0.95;
+		if (hasCargo && hasTauriConf) return 0.9;
+		return 0;
+	},
+
+	async readManifests(ctx: AdapterContext): Promise<VersionManifest[]> {
+		const manifests: VersionManifest[] = [];
+		for (const relPath of MANIFESTS) {
+			const absPath = join(ctx.repoRoot, relPath);
+			if (!existsSync(absPath)) continue;
+			try {
+				const content = await readFile(absPath, "utf-8");
+				const version = parseVersion(relPath, content);
+				if (version) {
+					manifests.push({ path: relPath, version, content });
+				}
+			} catch {
+				// ignore unreadable files
+			}
+		}
+		return manifests;
+	},
+
+	async bump(
+		ctx: AdapterContext,
+		bumpType: "patch" | "minor" | "major" | "prerelease",
+		newVersion?: string,
+	): Promise<BumpResult> {
+		// Determine canonical version
+		let finalVersion: string;
+
+		if (newVersion) {
+			finalVersion = newVersion;
+		} else {
+			// Read all manifests to determine current base version
+			const manifests = await this.readManifests(ctx);
+			const versions = manifests.map((m) => m.version);
+			const canonical = versions[0] ?? "0.0.0";
+
+			const parts = canonical.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 = canonical;
+					break;
+				default:
+					finalVersion = `${major}.${minor}.${patch + 1}`;
+			}
+		}
+
+		const actions: string[] = [];
+		const updated: VersionManifest[] = [];
+
+		// Write to all three manifests
+		for (const relPath of MANIFESTS) {
+			const absPath = join(ctx.repoRoot, relPath);
+			if (!existsSync(absPath)) continue;
+
+			if (ctx.verbose || ctx.dryRun) {
+				actions.push(
+					`Update ${relPath}: ${parseVersion(relPath, await readFile(absPath, "utf-8").catch(() => "")) ?? "?"} -> ${finalVersion}`,
+				);
+			}
+
+			await writeManifest(ctx, relPath, finalVersion);
+			updated.push({ path: relPath, 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);
+		const missing = MANIFESTS.filter(
+			(p) => !manifests.find((m) => m.path === p),
+		);
+		if (missing.length > 0) {
+			warnings.push(
+				`Missing manifest files (may be intentional): ${missing.join(", ")}`,
+			);
+		}
+
+		const versions = manifests.map((m) => m.version);
+		const unique = [...new Set(versions)];
+
+		if (unique.length > 1) {
+			errors.push(
+				`Version mismatch across Tauri 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> {
+		// package.json is the canonical source for Tauri apps (npm frontend)
+		const root = join(ctx.repoRoot, "package.json");
+		if (!existsSync(root)) return null;
+		try {
+			const content = await readFile(root, "utf-8");
+			return parsePackageJson(content);
+		} catch {
+			return null;
+		}
+	},
+};

package/scripts/release/orchestrator.ts

@@ -0,0 +1,278 @@
+/**
+ * Release orchestrator — picks the best adapter and runs the release.
+ *
+ * Architecture:
+ * 1. Detect which stack(s) apply to the repo (detector)
+ * 2. Select the best adapter (highest confidence, or compose multiple)
+ * 3. Run standard-version to create the git tag
+ * 4. Sync versions across all manifest files
+ * 5. Amend commit, push, and publish
+ *
+ * The adapter handles all manifest-specific logic.
+ * The orchestrator handles the git/npm plumbing.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "path";
+import { detectStacks, formatProfile } from "./adapters/detector.ts";
+import { nodeWorkspaceAdapter } from "./adapters/node-workspace.ts";
+import { tauriAdapter } from "./adapters/tauri.ts";
+import { rustAdapter } from "./adapters/rust.ts";
+import { pythonAdapter } from "./adapters/python.ts";
+import type { AdapterContext, ReleaseAdapter } from "./adapters/base.ts";
+
+const ADAPTERS: ReleaseAdapter[] = [
+	nodeWorkspaceAdapter,
+	tauriAdapter,
+	rustAdapter,
+	pythonAdapter,
+];
+
+/** All adapters, sorted by confidence for this repo */
+function rankedAdapters(ctx: AdapterContext): Array<{
+	adapter: ReleaseAdapter;
+	confidence: number;
+}> {
+	return ADAPTERS.map((a) => ({ adapter: a, confidence: a.detect(ctx) }))
+		.filter((r) => r.confidence > 0)
+		.sort((a, b) => b.confidence - a.confidence);
+}
+
+/** Run a git command, return trimmed stdout */
+function git(args: string[], cwd: string): string {
+	try {
+		return execSync(`git ${args.join(" ")}`, { cwd, encoding: "utf-8" }).trim();
+	} catch {
+		return "";
+	}
+}
+
+/** Run a git command, ignore errors */
+function gitQuiet(args: string[], cwd: string): void {
+	try {
+		execSync(`git ${args.join(" ")}`, { cwd, encoding: "utf-8" });
+	} catch {
+		// ignore
+	}
+}
+
+export interface ReleaseOptions {
+	repoRoot?: string;
+	dryRun?: boolean;
+	verbose?: boolean;
+	bumpType?: "patch" | "minor" | "major" | "prerelease";
+	newVersion?: string;
+	skipGit?: boolean;
+	skipNpm?: boolean;
+	skipPublish?: boolean;
+	/**
+	 * Skip running standard-version (tag creation).
+	 * Set to true when running locally - CI handles standard-version.
+	 */
+	skipStandardVersion?: boolean;
+}
+
+/**
+ * Detect the best adapter for a repo without running any changes.
+ */
+export function detect(options: ReleaseOptions = {}): string {
+	const repoRoot = resolve(options.repoRoot ?? process.cwd());
+	const ctx: AdapterContext = {
+		repoRoot,
+		dryRun: options.dryRun ?? false,
+		verbose: options.verbose ?? false,
+	};
+
+	const profile = detectStacks(ctx);
+	return formatProfile(profile);
+}
+
+/**
+ * Run the full release flow with the best adapter.
+ */
+export async function release(options: ReleaseOptions = {}): Promise<void> {
+	const repoRoot = resolve(options.repoRoot ?? process.cwd());
+	const dryRun = options.dryRun ?? false;
+	const verbose = options.verbose ?? false;
+	const ctx: AdapterContext = { repoRoot, dryRun, verbose };
+
+	// ── Step 0: Detect stacks ───────────────────────────────────────────────
+	const profile = detectStacks(ctx);
+	if (verbose) {
+		console.log(formatProfile(profile));
+	}
+
+	if (profile.unknown) {
+		console.warn(
+			"\n⚠️  No known stack detected. Run with --verbose to see detection results.",
+		);
+		console.warn("   Falling back to Node workspace adapter...\n");
+	}
+
+	// Pick the best adapter
+	const ranked = rankedAdapters(ctx);
+	const adapter = ranked[0]?.adapter ?? nodeWorkspaceAdapter;
+
+	if (verbose) {
+		console.log(`\n📦 Using adapter: ${adapter.name} (${adapter.id})`);
+	}
+
+	// ── Step 1: Run standard-version (only in CI, not locally) ───────────
+	// Local runs: skip standard-version, just bump versions
+	// CI runs: run standard-version to create tags
+	if (options.skipStandardVersion) {
+		console.log(`\n🚀 Release (${adapter.name})\n`);
+		console.log(`📦 Step 1: Skipping standard-version (run locally)`);
+		console.log(`   CI will run standard-version on tag push\n`);
+	} else {
+		const bumpArg = options.newVersion ?? options.bumpType ?? "patch";
+		const stdCmd = dryRun
+			? `npx standard-version --dry-run --release-as ${bumpArg}`
+			: `npx standard-version --release-as ${bumpArg}`;
+
+		console.log(`\n🚀 Release (${adapter.name})\n`);
+		if (!options.skipGit) {
+			console.log(`📦 Step 1: Running standard-version...`);
+			console.log(`   $ ${stdCmd}`);
+			if (!dryRun) {
+				try {
+					execSync(stdCmd, { cwd: repoRoot, stdio: "inherit" });
+				} catch {
+					console.error("standard-version failed.");
+					process.exit(1);
+				}
+			}
+		}
+	}
+
+	// ── Step 2: Read new version from git tag ─────────────────────────────
+	let newVersion: string | undefined;
+
+	// Only read from git tag if NOT skipping standard-version (i.e., in CI)
+	// When skipping standard-version (local runs), adapter.bump() calculates the next version
+	if (!options.skipStandardVersion && !options.skipGit) {
+		try {
+			const tags = git(["tag", "--sort=-v:refname"], repoRoot);
+			const latestTag = tags.split("\n")[0];
+			newVersion = latestTag.startsWith("v") ? latestTag.slice(1) : latestTag;
+		} catch {
+			// Fallback: read from adapter
+			newVersion = (await adapter.getCanonicalVersion(ctx)) ?? "0.0.0";
+		}
+	} else if (!options.skipGit) {
+		// skipStandardVersion=true (local): let adapter calculate next version
+		newVersion = undefined;
+	}
+
+	// Explicit --release-as=X.Y.Z always wins
+	if (options.newVersion) {
+		newVersion = options.newVersion;
+	}
+
+	const displayVersion = newVersion ?? `(calculated from ${options.bumpType ?? "patch"})`;
+	console.log(`\n📋 Step 2: Release version is ${displayVersion}`);
+
+	// ── Step 3: Sync all manifest versions ────────────────────────────────
+	const manifests = await adapter.readManifests(ctx);
+	console.log(
+		`\n📦 Step 3: Syncing ${manifests.length} manifest(s)...`,
+	);
+	if (verbose) {
+		for (const m of manifests) {
+			console.log(`   ${m.path}: ${m.version} -> (calculated)`);
+		}
+	}
+
+	const bumpResult = await adapter.bump(
+		ctx,
+		options.bumpType ?? "patch",
+		newVersion,
+	);
+	for (const action of bumpResult.actions) {
+		console.log(`   ${action}`);
+	}
+
+	// Get the actual new version (either provided or calculated by bump)
+	const actualVersion = bumpResult.newVersion;
+
+	// ── Step 4: Verify ──────────────────────────────────────────────────
+	console.log(`\n🔍 Step 4: Verifying...`);
+	const verifyResult = await adapter.verify(ctx, actualVersion);
+
+	for (const warning of verifyResult.warnings) {
+		console.warn(`   ⚠ ${warning}`);
+	}
+	for (const error of verifyResult.errors) {
+		console.error(`   ✖ ${error}`);
+	}
+
+	if (!verifyResult.ok && !dryRun) {
+		// In dry-run, versions aren't actually bumped yet, so mismatch is expected
+		console.error(
+			"\n✖ Verification failed. Fix the errors above before releasing.\n",
+		);
+		process.exit(1);
+	}
+
+	if (verifyResult.ok) {
+		console.log(`   ✓ All manifests synchronized to ${actualVersion}`);
+	} else if (dryRun) {
+		console.log(
+			`   ⚠ Verification skipped in dry-run (versions not yet bumped)`,
+		);
+	}
+
+	// ── Step 5: Git amend (include manifest changes in the tag commit) ───
+	if (!options.skipGit && !dryRun) {
+		console.log(`\n🔧 Step 5: Amending commit with manifest changes...`);
+		gitQuiet(["add", "-A"], repoRoot);
+		const status = git(["status", "--short"], repoRoot);
+		if (status) {
+			console.log(`   Staged:\n${status}`);
+			try {
+				gitQuiet(["commit", "--amend", "--no-edit"], repoRoot);
+				console.log(`   ✓ Committed (amended)`);
+			} catch {
+				console.warn(`   ⚠ Could not amend commit`);
+			}
+		} else {
+			console.log(`   No changes to commit`);
+		}
+	}
+
+	// ── Step 6: Push ────────────────────────────────────────────────────
+	if (!options.skipGit && !dryRun) {
+		console.log(`\n🚀 Step 6: Pushing to origin...`);
+		try {
+			execSync("git push --follow-tags origin develop", {
+				cwd: repoRoot,
+				stdio: "inherit",
+			});
+		} catch {
+			console.error("Git push failed.");
+			process.exit(1);
+		}
+	}
+
+	// ── Step 7: Publish to npm ────────────────────────────────────────────
+	if (!options.skipNpm && !options.skipPublish && !dryRun) {
+		const hasNpmPkg = existsSync(resolve(repoRoot, "package.json"));
+		if (hasNpmPkg) {
+			console.log(`\n📦 Step 7: Publishing to npm...`);
+			try {
+				execSync("npm publish --workspaces=false", {
+					cwd: repoRoot,
+					stdio: "inherit",
+				});
+			} catch {
+				console.error(
+					"npm publish failed. Check that you're logged in (npm login).",
+				);
+				process.exit(1);
+			}
+		}
+	}
+
+	console.log(`\n✅ Release ${actualVersion} complete (${adapter.name})\n`);
+}