pi-harness-runtime 1.1.445 → 1.1.447

package/scripts/release/actions-monitor.ts

@@ -1,357 +0,0 @@
-#!/usr/bin/env bun
-/**
- * GitHub Actions Monitor
- *
- * Polls a GitHub Actions run and watches it to completion.
- * Uses gh CLI which must be authenticated: gh auth login
- *
- * Usage:
- *   bun scripts/release/actions-monitor.ts --owner user --repo repo --run 123
- *   bun scripts/release/actions-monitor.ts --owner user --repo repo (latest run on current branch)
- *   bun scripts/release/actions-monitor.ts --detach         → fire and forget
- */
-
-import { execSync } from "node:child_process";
-
-const DEFAULT_POLL_INTERVAL_MS = 10_000;
-const MAX_POLL_MINUTES = 60;
-
-/** Raw action run from GitHub API */
-interface ActionRun {
-	id: number;
-	name: string;
-	status: "queued" | "in_progress" | "completed";
-	conclusion:
-		| "success"
-		| "failure"
-		| "cancelled"
-		| "skipped"
-		| "timed_out"
-		| "action_required"
-		| null;
-	html_url: string;
-	created_at: string;
-	updated_at: string;
-	head_branch: string;
-	run_number: number;
-	event: string;
-}
-
-interface MonitorOptions {
-	owner?: string;
-	repo?: string;
-	runId?: number;
-	pollIntervalMs?: number;
-	maxMinutes?: number;
-	verbose?: boolean;
-	detach?: boolean;
-}
-
-interface RunStatus {
-	status: string;
-	conclusion: string | null;
-	url: string;
-	runId: number;
-	name: string;
-	branch: string;
-	runNumber: number;
-	createdAt: string;
-	updatedAt: string;
-}
-
-// ── gh CLI helpers ────────────────────────────────────────────────────────────
-
-/** Execute gh command, return { stdout, status }. Never throws. */
-function ghQuiet(args: string[]): { stdout: string; status: number } {
-	try {
-		const stdout = execSync(`gh ${args.join(" ")}`, {
-			encoding: "utf-8",
-			timeout: 15_000,
-			maxBuffer: 10 * 1024 * 1024,
-		}).trim();
-		return { stdout, status: 0 };
-	} catch (e) {
-		const err = e as { status?: number; stderr?: string };
-		return { stdout: err.stderr ?? "", status: err.status ?? 1 };
-	}
-}
-
-/** Call gh api and parse JSON. Returns null on failure. */
-function ghApi<T>(path: string, extraArgs: string[] = []): T | null {
-	const { stdout, status } = ghQuiet(["api", path, ...extraArgs]);
-	if (status !== 0 || !stdout) return null;
-	try {
-		return JSON.parse(stdout) as T;
-	} catch {
-		return null;
-	}
-}
-
-// ── Repo / branch detection ────────────────────────────────────────────────────
-
-function getCurrentBranch(): string {
-	try {
-		return execSync("git branch --show-current", {
-			encoding: "utf-8",
-			timeout: 5000,
-		}).trim();
-	} catch {
-		return "develop";
-	}
-}
-
-function getRemoteRepo(): { owner: string; repo: string } | null {
-	const { stdout, status } = ghQuiet([
-		"repo",
-		"view",
-		"--json",
-		"owner,name",
-		"-q",
-		"{owner:.owner.login,repo:.name}",
-	]);
-	if (status !== 0) return null;
-	try {
-		const parsed = JSON.parse(stdout);
-		return { owner: parsed.owner, repo: parsed.repo };
-	} catch {
-		return null;
-	}
-}
-
-// ── Action run queries ─────────────────────────────────────────────────────────
-
-function getLatestRun(
-	owner: string,
-	repo: string,
-	branch?: string,
-): ActionRun | null {
-	const runs = ghApi<{ workflow_runs: ActionRun[] }>(
-		`repos/${owner}/${repo}/actions/runs`,
-		["-F", "per_page=1", ...(branch ? ["-F", `branch=${branch}`] : [])],
-	);
-	return runs?.workflow_runs?.[0] ?? null;
-}
-
-function getRunStatus(
-	owner: string,
-	repo: string,
-	runId: number,
-): RunStatus | null {
-	const run = ghApi<ActionRun>(
-		`repos/${owner}/${repo}/actions/runs/${runId}`,
-	);
-	if (!run) return null;
-	return {
-		status: run.status,
-		conclusion: run.conclusion,
-		url: run.html_url,
-		runId: run.id,
-		name: run.name,
-		branch: run.head_branch,
-		runNumber: run.run_number,
-		createdAt: run.created_at,
-		updatedAt: run.updated_at,
-	};
-}
-
-// ── Formatting ─────────────────────────────────────────────────────────────────
-
-function formatDuration(startIso: string): string {
-	const start = new Date(startIso).getTime();
-	const elapsed = Date.now() - start;
-	const min = Math.floor(elapsed / 60_000);
-	const sec = Math.floor((elapsed % 60_000) / 1000);
-	return min > 0 ? `${min}m ${sec}s` : `${sec}s`;
-}
-
-function formatConclusion(c: string | null): string {
-	switch (c) {
-		case "success":
-			return "✅ Success";
-		case "failure":
-			return "❌ Failed";
-		case "cancelled":
-			return "🚫 Cancelled";
-		case "timed_out":
-			return "⏱ Timed out";
-		case "skipped":
-			return "⏭ Skipped";
-		case "action_required":
-			return "⚠ Action required";
-		default:
-			return `? ${c ?? "unknown"}`;
-	}
-}
-
-const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧"];
-
-async function sleep(ms: number): Promise<void> {
-	return new Promise((r) => setTimeout(r, ms));
-}
-
-// ── Monitor ────────────────────────────────────────────────────────────────────
-
-/**
- * Poll a GitHub Actions run until completion.
- * Returns { conclusion, duration } when done (success, failure, or timeout).
- */
-export async function monitorRun(
-	owner: string,
-	repo: string,
-	runId: number,
-	options: MonitorOptions = {},
-): Promise<{ conclusion: string | null; duration: number }> {
-	const pollMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-	const maxMs = (options.maxMinutes ?? MAX_POLL_MINUTES) * 60 * 1000;
-	const startTime = Date.now();
-	let spin = 0;
-	let lastStatus = "";
-
-	while (Date.now() - startTime < maxMs) {
-		const status = getRunStatus(owner, repo, runId);
-		if (!status) {
-			console.warn(`[actions-monitor] Run ${runId} not found`);
-			break;
-		}
-
-		const elapsed = formatDuration(status.createdAt);
-
-		if (status.status !== lastStatus) {
-			if (options.verbose) {
-				console.log(`[actions-monitor] Status: ${status.status}`);
-			}
-			lastStatus = status.status;
-		}
-
-		if (status.status === "completed") {
-			const dur = Date.now() - startTime;
-			console.log(
-				`\n${formatConclusion(status.conclusion)} in ${elapsed} — ${status.url}`,
-			);
-			return { conclusion: status.conclusion, duration: dur };
-		}
-
-		// Still running
-		const dots = ".".repeat((spin % 3) + 1);
-		process.stdout.write(
-			`\r${SPINNER[spin++ % SPINNER.length]} [${elapsed}] ${status.name} #${status.runNumber} (${status.branch}) ${status.status}${dots}   `,
-		);
-
-		await sleep(pollMs);
-	}
-
-	// Timeout
-	const dur = Date.now() - startTime;
-	console.warn(`\n[actions-monitor] Timeout after ${MAX_POLL_MINUTES}m`);
-	return { conclusion: "timed_out", duration: dur };
-}
-
-/**
- * Find and monitor the latest run for a repo/branch.
- */
-export async function monitorLatest(
-	owner: string,
-	repo: string,
-	branch: string,
-	options: MonitorOptions = {},
-): Promise<{ runId: number; conclusion: string | null; duration: number } | null> {
-	const run = getLatestRun(owner, repo, branch);
-	if (!run) {
-		console.warn(`[actions-monitor] No runs found for ${branch}`);
-		return null;
-	}
-	console.log(
-		`Found run #${run.run_number} (${run.id}) — ${run.name} on ${run.head_branch}`,
-	);
-	return {
-		runId: run.id,
-		...(await monitorRun(owner, repo, run.id, options)),
-	};
-}
-
-// ── CLI ────────────────────────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-	const args = process.argv.slice(2);
-
-	const opts: MonitorOptions = {
-		pollIntervalMs: DEFAULT_POLL_INTERVAL_MS,
-		maxMinutes: MAX_POLL_MINUTES,
-		verbose: args.includes("--verbose"),
-		detach: args.includes("--detach"),
-	};
-
-	// Parse flags
-	for (const arg of args) {
-		const m = arg.match(/^--owner=(.+)$/);
-		if (m) { opts.owner = m[1]; continue; }
-		const r = arg.match(/^--repo=(.+)$/);
-		if (r) { opts.repo = r[1]; continue; }
-		const runM = arg.match(/^--run=(\d+)$/);
-		if (runM) { opts.runId = parseInt(runM[1], 10); continue; }
-		const pollM = arg.match(/^--poll=(\d+)$/);
-		if (pollM) { opts.pollIntervalMs = parseInt(pollM[1], 10) * 1000; }
-	}
-
-	// Resolve owner/repo from git remote if not provided
-	if (!opts.owner || !opts.repo) {
-		const remote = getRemoteRepo();
-		if (!remote) {
-			console.error(
-				"Error: No GitHub repo found. Use --owner and --repo flags, or run from a git repo.",
-			);
-			process.exit(1);
-		}
-		opts.owner ??= remote.owner;
-		opts.repo ??= remote.repo;
-	}
-
-	if (!opts.owner || !opts.repo) {
-		console.error("Error: --owner and --repo required");
-		process.exit(1);
-	}
-
-	// --detach: just show the run info and exit
-	if (opts.detach) {
-		const branch = getCurrentBranch();
-		const run = getLatestRun(opts.owner, opts.repo, branch);
-		if (run) {
-			console.log(
-				`Run #${run.run_number} (${run.id}) — ${run.name} [${run.status}]`,
-			);
-		} else {
-			console.log("No runs found");
-		}
-		return;
-	}
-
-	if (opts.runId) {
-		console.log(`Monitoring run #${opts.runId}...`);
-		const result = await monitorRun(
-			opts.owner,
-			opts.repo,
-			opts.runId,
-			opts,
-		);
-		process.exit(result.conclusion === "success" ? 0 : 1);
-	} else {
-		const branch = getCurrentBranch();
-		console.log(`Monitoring latest run on branch '${branch}'...`);
-		const result = await monitorLatest(
-			opts.owner,
-			opts.repo,
-			branch,
-			opts,
-		);
-		if (!result) {
-			console.error("No runs found");
-			process.exit(1);
-		}
-		process.exit(result.conclusion === "success" ? 0 : 1);
-	}
-}
-
-main().catch((err) => {
-	console.error("Error:", (err as Error).message);
-	process.exit(1);
-});

package/scripts/release/adapters/base.ts

@@ -1,95 +0,0 @@
-/**
- * Base release adapter interface.
- *
- * All stack-specific adapters implement this interface.
- * The detector picks the right adapter(s) for the repo.
- */
-
-export interface AdapterContext {
-	/** Absolute path to the repo root */
-	repoRoot: string;
-	/** Dry-run mode — describe actions without executing */
-	dryRun: boolean;
-	/** Verbose output */
-	verbose: boolean;
-}
-
-export interface VersionManifest {
-	/** Path relative to repoRoot */
-	path: string;
-	/** Current version string (read from file) */
-	version: string;
-	/** Raw content (for re-serialization) */
-	content: string;
-}
-
-export interface BumpResult {
-	/** The new version after bumping */
-	newVersion: string;
-	/** All manifests that were updated */
-	updated: VersionManifest[];
-	/** Description of what was done */
-	actions: string[];
-}
-
-export interface VerificationResult {
-	/** True if verification passed */
-	ok: boolean;
-	/** List of issues found */
-	errors: string[];
-	/** Warnings that don't block release */
-	warnings: string[];
-}
-
-/**
- * Stack-specific release adapter.
- *
- * Each adapter:
- * 1. Knows which files to inspect/update for its stack
- * 2. Provides version reading/writing
- * 3. Provides bump logic (patch/minor/major/custom)
- * 4. Provides verification rules
- */
-export interface ReleaseAdapter {
-	/** Unique identifier for this adapter */
-	id: string;
-
-	/** Human-readable name */
-	name: string;
-
-	/**
-	 * Detect whether this adapter applies to the given repo.
-	 * Return a confidence score 0-1. Higher = more confident.
-	 */
-	detect(ctx: AdapterContext): number;
-
-	/**
-	 * Read all version manifests for this stack.
-	 * Returns empty array if no manifests found.
-	 */
-	readManifests(ctx: AdapterContext): Promise<VersionManifest[]>;
-
-	/**
-	 * Bump version in all relevant manifests.
-	 * Returns the new version and list of updated files.
-	 */
-	bump(
-		ctx: AdapterContext,
-		bumpType: "patch" | "minor" | "major" | "prerelease",
-		newVersion?: string,
-	): Promise<BumpResult>;
-
-	/**
-	 * Verify that all manifests are consistent and release is safe.
-	 * Should check: versions match, required files exist, tag is correct.
-	 */
-	verify(
-		ctx: AdapterContext,
-		expectedVersion: string,
-	): Promise<VerificationResult>;
-
-	/**
-	 * Get the canonical version from the most authoritative manifest.
-	 */
-	getCanonicalVersion(ctx: AdapterContext): Promise<string | null>;
-}

package/scripts/release/adapters/detector.ts

@@ -1,181 +0,0 @@
-/**
- * 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");
-}