pi-harness-runtime 1.1.444 → 1.1.446

package/packages/worktree/src/worktree.ts

@@ -1,331 +0,0 @@
-/**
- * Git Worktree Manager — RFC-0005
- *
- * Creates isolated workspaces for parallel or recoverable coding tasks.
- *
- * Goals:
- * - avoid branch conflicts
- * - preserve partial work
- * - allow reviewer agent to inspect diffs
- * - allow separate models to work on separate tasks
- */
-
-import type { WorktreeInfo } from "../../types/dist/runtime-types.js";
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-
-/**
- * The file system calls the manager needs.
- *
- * The dependency is injected so that a test never has to replace `node:fs`
- * for the whole process: a module mock is global and would break every test
- * file that runs later.
- */
-export interface WorktreeFileSystem {
-	existsSync(path: string): boolean;
-	mkdirSync(path: string, options: { recursive: true }): string | undefined;
-	writeFileSync(path: string, data: string, options: { encoding: "utf-8" }): void;
-	readFileSync(path: string, encoding: "utf-8"): string;
-}
-
-/** The options the command runner receives. */
-export interface WorktreeExecOptions {
-	cwd: string;
-	encoding: "utf-8";
-	stdio: ["pipe", "pipe", "pipe"];
-}
-
-/** The command runner the manager needs (Git). */
-export type WorktreeCommandRunner = (command: string, options: WorktreeExecOptions) => string;
-
-/** Run a command and return its output. */
-function runCommand(command: string, options: WorktreeExecOptions): string {
-	try {
-		return execSync(command, options);
-	} catch (error) {
-		throw error instanceof Error ? error : new Error(String(error));
-	}
-}
-
-export interface WorktreeOptions {
-	rootDir: string;
-	baseBranch?: string;
-	/** The file system to use; the real one by default. */
-	fs?: WorktreeFileSystem;
-	/** The command runner to use; `execSync` by default. */
-	exec?: WorktreeCommandRunner;
-}
-
-export interface CreateWorktreeOptions {
-	name: string;
-	branch?: string;
-	jobId?: string;
-	taskId?: string;
-	startPoint?: string;
-}
-
-export interface WorktreeDiff {
-	file: string;
-	status: "added" | "modified" | "deleted" | "renamed";
-	insertions?: number;
-	deletions?: number;
-}
-
-export class WorktreeManager {
-	private readonly rootDir: string;
-	private readonly baseBranch: string;
-	private readonly metaPath: string;
-	private readonly fs: WorktreeFileSystem;
-	private readonly exec: WorktreeCommandRunner;
-
-	constructor(options: WorktreeOptions) {
-		this.rootDir = options.rootDir;
-		this.baseBranch = options.baseBranch ?? "main";
-		this.metaPath = join(this.rootDir, ".worktrees.json");
-		this.fs = options.fs ?? { existsSync, mkdirSync, writeFileSync, readFileSync };
-		this.exec = options.exec ?? runCommand;
-	}
-
-	/**
-	 * Create a new worktree
-	 */
-	async create(options: CreateWorktreeOptions): Promise<WorktreeInfo> {
-		const name = options.name.replace(/[^a-zA-Z0-9-_]/g, "-");
-		const branch = options.branch ?? `worktree/${name}`;
-		const path = join(this.rootDir, "worktrees", name);
-
-		// Ensure directory exists
-		this.fs.mkdirSync(dirname(path), { recursive: true });
-
-		// Create git worktree
-		const startPoint = options.startPoint ?? this.baseBranch;
-		const worktreePath = this.execGit([
-			"worktree",
-			"add",
-			"-b",
-			branch,
-			path,
-			startPoint,
-		]);
-
-		// Record metadata
-		const worktree: WorktreeInfo = {
-			name,
-			path: worktreePath,
-			branch,
-			jobId: options.jobId,
-			taskId: options.taskId,
-			createdAt: new Date().toISOString(),
-			status: "active",
-		};
-
-		this.saveWorktree(worktree);
-
-		return worktree;
-	}
-
-	/**
-	 * List all worktrees
-	 */
-	async list(): Promise<WorktreeInfo[]> {
-		if (!this.fs.existsSync(this.metaPath)) {
-			return [];
-		}
-
-		try {
-			const content = this.fs.readFileSync(this.metaPath, "utf-8");
-			return JSON.parse(content) as WorktreeInfo[];
-		} catch {
-			return [];
-		}
-	}
-
-	/**
-	 * Get worktree by name
-	 */
-	async get(name: string): Promise<WorktreeInfo | null> {
-		const worktrees = await this.list();
-		return worktrees.find((w) => w.name === name) ?? null;
-	}
-
-	/**
-	 * Get worktree by job ID
-	 */
-	async getByJob(jobId: string): Promise<WorktreeInfo | null> {
-		const worktrees = await this.list();
-		return worktrees.find((w) => w.jobId === jobId) ?? null;
-	}
-
-	/**
-	 * Remove a worktree
-	 */
-	async remove(name: string, force: boolean = false): Promise<void> {
-		const worktree = await this.get(name);
-		if (!worktree) {
-			throw new Error(`Worktree ${name} not found`);
-		}
-
-		// Remove git worktree
-		this.execGit(["worktree", "remove", worktree.path, force ? "--force" : ""]);
-
-		// Remove from metadata
-		const worktrees = await this.list();
-		const updated = worktrees.filter((w) => w.name !== name);
-		this.saveAllWorktrees(updated);
-	}
-
-	/**
-	 * Prune stale worktrees
-	 */
-	async prune(): Promise<string[]> {
-		const output = this.execGit(["worktree", "list", "--porcelain"]);
-		const lines = output.split("\n");
-		const pruned: string[] = [];
-
-		// Parse git worktree list
-		const worktreePaths: string[] = [];
-		for (const line of lines) {
-			if (line.startsWith("worktree ")) {
-				worktreePaths.push(line.replace("worktree ", "").trim());
-			}
-		}
-
-		// Check our tracked worktrees
-		const tracked = await this.list();
-		for (const worktree of tracked) {
-			if (!worktreePaths.includes(worktree.path)) {
-				// Git worktree no longer exists
-				worktree.status = "abandoned";
-				pruned.push(worktree.name);
-			}
-		}
-
-		this.saveAllWorktrees(tracked);
-
-		return pruned;
-	}
-
-	/**
-	 * Get diff between worktree and base
-	 */
-	async getDiff(worktreePath: string): Promise<WorktreeDiff[]> {
-		const output = this.execGit(["diff", "--stat", `main...${worktreePath}`], {
-			cwd: worktreePath,
-		});
-
-		const diffs: WorktreeDiff[] = [];
-		const lines = output.split("\n");
-
-		for (const line of lines) {
-			if (!line.includes("|")) continue;
-
-			const [file, stats] = line.split("|").map((s) => s.trim());
-			if (!file || !stats) continue;
-
-			let status: WorktreeDiff["status"] = "modified";
-			if (stats.startsWith("+")) status = "added";
-			else if (stats.startsWith("-")) status = "deleted";
-
-			const match = stats.match(/\+(\d+)/);
-			const insertions = match ? parseInt(match[1], 10) : undefined;
-
-			const delMatch = stats.match(/-(\d+)/);
-			const deletions = delMatch ? parseInt(delMatch[1], 10) : undefined;
-
-			diffs.push({ file, status, insertions, deletions });
-		}
-
-		return diffs;
-	}
-
-	/**
-	 * Get uncommitted changes
-	 */
-	async getUncommitted(worktreePath: string): Promise<WorktreeDiff[]> {
-		const output = this.execGit(["diff", "--numstat"], { cwd: worktreePath });
-
-		const diffs: WorktreeDiff[] = [];
-		const lines = output.split("\n");
-
-		for (const line of lines) {
-			const parts = line.split("\t");
-			if (parts.length < 3) continue;
-
-			const [ins, del, file] = parts;
-			diffs.push({
-				file,
-				status: "modified",
-				insertions: parseInt(ins, 10) || 0,
-				deletions: parseInt(del, 10) || 0,
-			});
-		}
-
-		return diffs;
-	}
-
-	/**
-	 * Mark worktree as merged
-	 */
-	async markMerged(name: string): Promise<void> {
-		const worktrees = await this.list();
-		const worktree = worktrees.find((w) => w.name === name);
-		if (worktree) {
-			worktree.status = "merged";
-			this.saveAllWorktrees(worktrees);
-		}
-	}
-
-	/**
-	 * Execute git command
-	 */
-	private execGit(args: string[], options?: { cwd?: string }): string {
-		try {
-			const cwd = options?.cwd ?? this.rootDir;
-			return this.exec(["git", ...args].join(" "), {
-				cwd,
-				encoding: "utf-8",
-				stdio: ["pipe", "pipe", "pipe"],
-			}).trim();
-		} catch (error) {
-			const e = error as { message?: string };
-			throw new Error(`Git command failed: ${e.message ?? error}`);
-		}
-	}
-
-	/**
-	 * Save worktree to metadata
-	 */
-	private saveWorktree(worktree: WorktreeInfo): void {
-		const current = this.listSync();
-		const idx = current.findIndex((w) => w.name === worktree.name);
-		if (idx >= 0) {
-			current[idx] = worktree;
-		} else {
-			current.push(worktree);
-		}
-		this.saveAllWorktrees(current);
-	}
-
-	/**
-	 * Save all worktrees
-	 */
-	private saveAllWorktrees(worktrees: WorktreeInfo[]): void {
-		this.fs.mkdirSync(dirname(this.metaPath), { recursive: true });
-		this.fs.writeFileSync(this.metaPath, JSON.stringify(worktrees, null, 2), { encoding: "utf-8" });
-	}
-
-	/**
-	 * List worktrees synchronously
-	 */
-	private listSync(): WorktreeInfo[] {
-		if (!this.fs.existsSync(this.metaPath)) {
-			return [];
-		}
-		try {
-			return JSON.parse(this.fs.readFileSync(this.metaPath, "utf-8")) as WorktreeInfo[];
-		} catch {
-			return [];
-		}
-	}
-}

package/scripts/build-packages.ts

@@ -1,162 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Build every workspace package and fail loudly when a required output is
- * missing.
- *
- * Why this exists:
- *
- * 1. The old build command ended every package build with `|| true`, so a
- *    package that failed to compile was reported as a success. The release
- *    then published a package whose entry point did not exist.
- * 2. `tsc -p` skips emitting a file when its `.tsbuildinfo` says the file is
- *    unchanged. Deleting the build output without deleting the build info
- *    therefore produced a package with missing files. The build info is
- *    removed before every build so that the output always matches the source.
- * 3. A package with a known type error still emits its JavaScript (that is
- *    what `tsc` does without `noEmitOnError`). Those type errors are tracked
- *    by `scripts/typecheck-packages.mjs`; this script only cares about the
- *    files that the build was supposed to produce.
- *
- * Usage:
- *   bun scripts/build-packages.ts            # build everything
- *   bun scripts/build-packages.ts --check    # build and verify the entries
- */
-
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
-import { join, resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const PACKAGES_DIR = join(ROOT, "packages");
-const TSC = join(ROOT, "node_modules", ".bin", "tsc");
-
-/**
- * Packages that must not be compiled by this script.
- *
- * A package belongs here only when it cannot be compiled at all (for
- * example a vendored app without TypeScript sources). Every other package
- * must build, and a build failure must be reported instead of ignored.
- */
-const SKIPPED = new Set<string>();
-
-interface BuildResult {
-	package: string;
-	failed: boolean;
-	errorCount: number;
-	emitted: number;
-}
-
-function packageDirs(): string[] {
-	if (!existsSync(PACKAGES_DIR)) return [];
-	return readdirSync(PACKAGES_DIR)
-		.map((entry) => join(PACKAGES_DIR, entry))
-		.filter((dir) => {
-			try {
-				return statSync(dir).isDirectory();
-			} catch {
-				return false;
-			}
-		})
-		.filter((dir) => existsSync(join(dir, "tsconfig.json")));
-}
-
-/** The files a package manifest promises to publish. */
-function manifestEntries(dir: string): string[] {
-	const manifestPath = join(dir, "package.json");
-	if (!existsSync(manifestPath)) return [];
-	let manifest: { main?: string; exports?: unknown; bin?: unknown };
-	try {
-		manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-	} catch {
-		return [];
-	}
-	const entries: string[] = [];
-	if (typeof manifest.main === "string") entries.push(manifest.main);
-	if (typeof manifest.bin === "string") entries.push(manifest.bin);
-	else if (manifest.bin && typeof manifest.bin === "object") {
-		for (const value of Object.values(manifest.bin as Record<string, string>)) {
-			if (typeof value === "string") entries.push(value);
-		}
-	}
-	const walk = (node: unknown): void => {
-		if (typeof node === "string") {
-			if (node.startsWith("./")) entries.push(node);
-			return;
-		}
-		if (node && typeof node === "object") {
-			for (const value of Object.values(node as Record<string, unknown>)) walk(value);
-		}
-	};
-	walk(manifest.exports);
-	return [...new Set(entries)];
-}
-
-/** Remove the incremental build state so that every file is emitted again. */
-function clearBuildState(dir: string): void {
-	for (const entry of readdirSync(dir)) {
-		if (entry.endsWith(".tsbuildinfo")) {
-			rmSync(join(dir, entry), { force: true });
-		}
-	}
-}
-
-if (!existsSync(TSC)) {
-	console.error(`build: ${TSC} not found - run "bun install" first`);
-	process.exit(1);
-}
-
-const results: BuildResult[] = [];
-
-for (const dir of packageDirs()) {
-	const name = dir.slice(PACKAGES_DIR.length + 1);
-	if (SKIPPED.has(name)) {
-		console.log(`skip  ${name} (excluded from the build)`);
-		continue;
-	}
-
-	clearBuildState(dir);
-
-	const run = spawnSync(TSC, ["-p", join(dir, "tsconfig.json"), "--skipLibCheck"], {
-		cwd: ROOT,
-		encoding: "utf8",
-	});
-	const output = `${run.stdout ?? ""}${run.stderr ?? ""}`;
-	const errorCount = (output.match(/error TS/g) ?? []).length;
-	const failed = run.status !== 0;
-
-	const emitted = manifestEntries(dir).filter((entry) => existsSync(join(dir, entry))).length;
-
-	results.push({ package: name, failed, errorCount, emitted });
-
-	if (failed) {
-		// The type errors are tracked by the typecheck baseline. Print them so
-		// that a new error is visible, but keep building the other packages.
-		console.log(`warn  ${name} (${errorCount} type error(s))`);
-	} else {
-		console.log(`ok    ${name}`);
-	}
-}
-
-const failed = results.filter((result) => result.failed);
-const missing: string[] = [];
-for (const result of results) {
-	const dir = join(PACKAGES_DIR, result.package);
-	for (const entry of manifestEntries(dir)) {
-		if (!existsSync(join(dir, entry))) {
-			missing.push(`${result.package} publishes ${entry} but the file was not built`);
-		}
-	}
-}
-
-console.log(
-	`\nbuild: ${results.length} package(s) built, ${failed.length} with type errors`,
-);
-
-if (missing.length > 0) {
-	console.error("\nbuild FAILED - required output is missing:");
-	for (const item of missing) console.error(`  - ${item}`);
-	process.exit(1);
-}
-
-console.log("build: every published entry point exists");

package/scripts/check-sensitive-terms.d.mts

@@ -1,116 +0,0 @@
-/**
- * The types of the sensitive term check.
- *
- * The check is a plain JavaScript module on purpose: the pre-push hook
- * runs it on the machine of a user who may have no build tools at all,
- * and the workflow runs it with the node of the runner. A TypeScript
- * source would ask both for a compiler they do not have.
- *
- * The declarations live here so that the TypeScript side of the
- * repository - the package verification - can use the check without
- * knowing anything about JavaScript.
- */
-
-/** A place where a term was found. The path and the line, and nothing else. */
-export interface SensitiveHit {
-	/** The path of the file, relative to the scanned root. */
-	path: string;
-	/** The line of the hit. 0 when the path itself holds the term. */
-	line: number;
-}
-
-/** What a scan found. */
-export interface SensitiveScanResult {
-	/** Every place a term was found. */
-	hits: SensitiveHit[];
-	/** How many files were looked at. */
-	scanned: number;
-	/** What was scanned, in words. */
-	mode: string;
-}
-
-/** The terms of a list: one term per line, empty lines and comments skipped. */
-export function parseTerms(text: string): string[];
-
-/** The terms of a file. A file that cannot be read is no terms. */
-export function readTermsFile(path: string | undefined): string[];
-
-/** The repository of a checkout, from its origin remote. */
-export function repositoryFromRemote(cwd?: string): string | null;
-
-/** The terms of the environment: SENSITIVE_TERMS, or PI_SENSITIVE_TERMS_FILE. */
-export function termsFromEnv(env?: Record<string, string | undefined>): string[];
-
-/** Does a line hold one of the terms? A plain, case-insensitive fragment. */
-export function lineHasTerm(line: string, terms: string[]): boolean;
-
-/** The added lines of a unified diff, with the line they have in the new file. */
-export function addedLines(patch: string): { line: number; text: string }[];
-
-/** The lines of a whole file. */
-export function fileLines(content: string): { line: number; text: string }[];
-
-/** Does a path hold a term? */
-export function pathHasTerm(path: string, terms: string[]): boolean;
-
-/** Hide the terms in a text. */
-export function redactTerms(text: string, terms: string[]): string;
-
-/** Scan a unified diff for the terms. */
-export function scanPatch(patch: string, path: string, terms: string[]): SensitiveHit[];
-
-/** Scan a whole text for the terms. */
-export function scanText(text: string, path: string, terms: string[]): SensitiveHit[];
-
-/** The report of a scan. It names the places and never a term. */
-export function formatReport(args: {
-	hits: SensitiveHit[];
-	scanned: number;
-	mode: string;
-	terms?: string[];
-}): string;
-
-/** The files of a directory tree. A symlink is not followed. */
-export function listTreeFiles(
-	dir: string,
-	root?: string,
-	out?: { relative: string; absolute: string }[],
-): { relative: string; absolute: string }[];
-
-/** Scan a directory tree for the terms. */
-export function scanTree(dir: string, terms: string[]): SensitiveScanResult;
-
-/** Scan a range of commits for the terms. */
-export function scanRange(
-	range: string,
-	terms: string[],
-	cwd?: string,
-): SensitiveScanResult;
-
-/** A commit of a range. */
-export interface SensitiveCommit {
-	/** The commit id. */
-	sha: string;
-	/** The message of the commit. */
-	message: string;
-}
-
-/** The commits of a range, with their messages. */
-export function commitMessages(
-	range: string,
-	cwd?: string,
-): SensitiveCommit[];
-
-/** Scan the commit messages of a range for the terms. */
-export function scanCommitMessages(
-	range: string,
-	terms: string[],
-	cwd?: string,
-): SensitiveScanResult;
-
-/** The exit code of a clean run. */
-export const EXIT_CLEAN: number;
-/** The exit code of a run that found a term. */
-export const EXIT_FOUND: number;
-/** The exit code of a run that could not check anything. */
-export const EXIT_UNAVAILABLE: number;