pi-harness-runtime 0.10.12 → 0.10.13

package/scripts/release/adapters/detector.ts

@@ -0,0 +1,181 @@
+/**
+ * Repo detector — identifies which release adapter(s) apply to a repo.
+ *
+ * Detection is based on file presence, not heuristics about content.
+ * Each adapter returns a confidence score 0-1.
+ * The orchestrator picks the adapter with the highest score.
+ */
+
+import type { AdapterContext } from "./base.ts";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "path";
+
+/** A detected stack with its confidence score */
+export interface StackDetection {
+	id: string;
+	name: string;
+	confidence: number;
+	hints: string[];
+}
+
+/** All detected stacks for a repo */
+export interface RepoProfile {
+	repoRoot: string;
+	stacks: StackDetection[];
+	unknown: boolean;
+}
+
+export interface DetectionHints {
+	hasPackageJson: boolean;
+	hasWorkspaces: boolean;
+	hasNodeModules: boolean;
+	hasCargoToml: boolean;
+	hasTauriCargoToml: boolean;
+	hasTauriManifest: boolean;
+	hasPyprojectToml: boolean;
+	hasSetupPy: boolean;
+	hasCargoLock: boolean;
+	hasPackageLockJson: boolean;
+	hasYarnLock: boolean;
+	hasPnpmLockYaml: boolean;
+	hasBunLock: boolean;
+}
+
+function hasWorkspacesField(repoRoot: string): boolean {
+	try {
+		const pkgPath = join(repoRoot, "package.json");
+		if (!existsSync(pkgPath)) return false;
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		return !!pkg.workspaces;
+	} catch {
+		return false;
+	}
+}
+
+function gatherHints(ctx: AdapterContext): DetectionHints {
+	const root = ctx.repoRoot;
+	return {
+		hasPackageJson: existsSync(join(root, "package.json")),
+		hasWorkspaces: hasWorkspacesField(root),
+		hasNodeModules: existsSync(join(root, "node_modules")),
+		hasCargoToml: existsSync(join(root, "Cargo.toml")),
+		hasTauriCargoToml: existsSync(join(root, "src-tauri", "Cargo.toml")),
+		hasTauriManifest:
+			existsSync(join(root, "src-tauri", "tauri.conf.json")) ||
+			existsSync(join(root, "src-tauri", "Cargo.toml")),
+		hasPyprojectToml: existsSync(join(root, "pyproject.toml")),
+		hasSetupPy: existsSync(join(root, "setup.py")),
+		hasCargoLock: existsSync(join(root, "Cargo.lock")),
+		hasPackageLockJson: existsSync(join(root, "package-lock.json")),
+		hasYarnLock: existsSync(join(root, "yarn.lock")),
+		hasPnpmLockYaml: existsSync(join(root, "pnpm-lock.yaml")),
+		hasBunLock: existsSync(join(root, "bun.lock")),
+	};
+}
+
+/**
+ * Detect all applicable stacks for a repo.
+ *
+ * Confidence:
+ * - 0.95: definitive (correlating files present)
+ * - 0.85: strong (primary file + ecosystem indicator)
+ * - 0.7: moderate (primary file only)
+ * - 0.0: not detected
+ */
+export function detectStacks(ctx: AdapterContext): RepoProfile {
+	const hints = gatherHints(ctx);
+	const stacks: StackDetection[] = [];
+
+	// Tauri Desktop App
+	if (
+		hints.hasTauriManifest &&
+		(hints.hasCargoToml || hints.hasTauriCargoToml)
+	) {
+		stacks.push({
+			id: "tauri",
+			name: "Tauri Desktop App",
+			confidence: 0.95,
+			hints: ["src-tauri/Cargo.toml", "src-tauri/tauri.conf.json"],
+		});
+	}
+
+	// Node.js / npm Workspace (monorepo)
+	// Strong: package.json + workspaces field + lock file
+	if (hints.hasPackageJson && hints.hasWorkspaces) {
+		const hasLock =
+			hints.hasPackageLockJson ||
+			hints.hasYarnLock ||
+			hints.hasPnpmLockYaml ||
+			hints.hasBunLock;
+		stacks.push({
+			id: "node-workspace",
+			name: "Node.js / npm",
+			confidence: hasLock ? 0.95 : 0.85,
+			hints: ["package.json", "workspaces"],
+		});
+	}
+
+	// Plain Node.js repo (no workspaces)
+	if (hints.hasPackageJson && !hints.hasWorkspaces) {
+		stacks.push({
+			id: "node-workspace",
+			name: "Node.js / npm",
+			confidence: 0.7,
+			hints: ["package.json"],
+		});
+	}
+
+	// Rust crate (root Cargo.toml, no Tauri)
+	if (hints.hasCargoToml && !hints.hasTauriManifest) {
+		stacks.push({
+			id: "rust",
+			name: "Rust Crate",
+			confidence: 0.95,
+			hints: ["Cargo.toml"],
+		});
+	}
+
+	// Python package
+	if (hints.hasPyprojectToml) {
+		stacks.push({
+			id: "python",
+			name: "Python Package",
+			confidence: 0.95,
+			hints: ["pyproject.toml"],
+		});
+	} else if (hints.hasSetupPy) {
+		stacks.push({
+			id: "python",
+			name: "Python Package",
+			confidence: 0.85,
+			hints: ["setup.py"],
+		});
+	}
+
+	stacks.sort((a, b) => b.confidence - a.confidence);
+	return { repoRoot: ctx.repoRoot, stacks, unknown: stacks.length === 0 };
+}
+
+/** Get the best adapter ID, or null if unknown */
+export function bestAdapter(ctx: AdapterContext): string | null {
+	const profile = detectStacks(ctx);
+	return profile.stacks[0]?.id ?? null;
+}
+
+/** Human-readable profile for verbose/dry-run output */
+export function formatProfile(profile: RepoProfile): string {
+	const lines: string[] = [`Repo: ${profile.repoRoot}`];
+
+	if (profile.unknown) {
+		lines.push("  No known stack detected — release adapters may not apply.");
+		return lines.join("\n");
+	}
+
+	lines.push("  Detected stacks:");
+	for (const stack of profile.stacks) {
+		const pct = Math.round(stack.confidence * 100);
+		lines.push(`    ${pct}%  ${stack.name} (${stack.id})`);
+		lines.push(`         hints: ${stack.hints.join(", ")}`);
+	}
+	return lines.join("\n");
+}

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;
+	},
+};