ultimate-pi 0.19.1 → 0.22.0

package/.pi/lib/harness-anchored-edit/types.ts

@@ -0,0 +1,19 @@
+export type AnchoredEditType = "replace" | "insert_after" | "insert_before";
+
+export interface AnchoredEdit {
+	anchor: string;
+	end_anchor?: string;
+	edit_type?: AnchoredEditType;
+	text: string;
+}
+
+export interface ResolvedAnchoredEdit {
+	lineIdx: number;
+	endIdx: number;
+	edit: AnchoredEdit;
+}
+
+export interface FailedAnchoredEdit {
+	edit: AnchoredEdit;
+	error: string;
+}

package/.pi/lib/harness-artifact-gate.ts

@@ -7,6 +7,10 @@ import { access, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { validateAgainstHarnessSchema } from "./harness-schema-validate.js";
+import {
+	TASK_CLARIFICATION_ARTIFACT,
+	validateTaskClarificationDoc,
+} from "./plan-task-clarification.js";
 
 export interface ArtifactGateResult {
 	ok: boolean;
@@ -19,12 +23,15 @@ const ARTIFACT_SCHEMA: Record<string, string> = {
 	"artifacts/implementation-research.yaml":
 		"plan-implementation-research-brief.schema.json",
 	"artifacts/stack.yaml": "plan-stack-brief.schema.json",
+	"artifacts/task-clarification.yaml": "plan-task-clarification.schema.json",
 	"artifacts/planning-context.yaml": "plan-planning-context.schema.json",
 	"artifacts/eval-verdict.yaml": "eval-verdict.schema.json",
 	"artifacts/adversary-report.yaml": "adversary-report.schema.json",
+	"artifacts/sentrux-repair-plan.yaml": "sentrux-repair-plan.schema.json",
 };
 
 const PREREQUISITE_ORDER: Record<string, string[]> = {
+	"artifacts/planning-context.yaml": [TASK_CLARIFICATION_ARTIFACT],
 	"artifacts/hypothesis.yaml": ["artifacts/decomposition.yaml"],
 	"artifacts/implementation-research.yaml": [
 		"artifacts/decomposition.yaml",
@@ -53,6 +60,63 @@ function artifactStatusBad(doc: Record<string, unknown>): string | null {
 	return null;
 }
 
+async function validatePlanningContextArtifact(
+	normalized: string,
+	doc: Record<string, unknown>,
+): Promise<string[]> {
+	const errors: string[] = [];
+	if (normalized !== "artifacts/planning-context.yaml") return errors;
+	const statusErr = artifactStatusBad(doc);
+	if (statusErr) errors.push(`${normalized}: ${statusErr}`);
+	const coverage = doc.coverage as Record<string, unknown> | undefined;
+	if (!coverage || typeof coverage !== "object") return errors;
+	for (const lane of ["architecture", "structure"] as const) {
+		const laneDoc = coverage[lane] as Record<string, unknown> | undefined;
+		const laneStatus = String(laneDoc?.status ?? "").toLowerCase();
+		if (laneStatus !== "ok" && laneStatus !== "partial") {
+			errors.push(
+				`${normalized}: coverage.${lane}.status must be ok or partial (got "${laneStatus || "missing"}")`,
+			);
+		}
+	}
+	return errors;
+}
+
+async function validateArtifactPrerequisites(
+	runRoot: string,
+	normalized: string,
+	prereqs: string[],
+): Promise<string[]> {
+	const errors: string[] = [];
+	for (const prereq of prereqs) {
+		const prereqPath = join(runRoot, prereq);
+		if (!(await fileExists(prereqPath))) {
+			errors.push(`${normalized}: prerequisite missing (${prereq})`);
+			continue;
+		}
+		if (prereq !== TASK_CLARIFICATION_ARTIFACT) continue;
+		try {
+			const raw = await readFile(prereqPath, "utf-8");
+			const prereqDoc = parseYaml(raw) as Record<string, unknown>;
+			const clar = validateTaskClarificationDoc(prereqDoc, {
+				requireReady: true,
+			});
+			if (!clar.ok) {
+				errors.push(
+					...clar.errors.map(
+						(e) => `${normalized}: prerequisite ${prereq} — ${e}`,
+					),
+				);
+			}
+		} catch {
+			errors.push(
+				`${normalized}: prerequisite ${prereq} invalid or unreadable`,
+			);
+		}
+	}
+	return errors;
+}
+
 export async function validateHarnessArtifactFile(
 	runRoot: string,
 	relPath: string,
@@ -102,32 +166,22 @@ export async function validateHarnessArtifactFile(
 		}
 	}
 
-	if (doc && normalized === "artifacts/planning-context.yaml") {
-		const statusErr = artifactStatusBad(doc);
-		if (statusErr) {
-			errors.push(`${normalized}: ${statusErr}`);
-		}
-		const coverage = doc.coverage as Record<string, unknown> | undefined;
-		if (coverage && typeof coverage === "object") {
-			for (const lane of ["architecture", "structure"] as const) {
-				const laneDoc = coverage[lane] as Record<string, unknown> | undefined;
-				const laneStatus = String(laneDoc?.status ?? "").toLowerCase();
-				if (laneStatus !== "ok" && laneStatus !== "partial") {
-					errors.push(
-						`${normalized}: coverage.${lane}.status must be ok or partial (got "${laneStatus || "missing"}")`,
-					);
-				}
-			}
+	if (doc && normalized === TASK_CLARIFICATION_ARTIFACT) {
+		const clar = validateTaskClarificationDoc(doc, { requireReady: true });
+		if (!clar.ok) {
+			errors.push(...clar.errors.map((e) => `${normalized}: ${e}`));
 		}
 	}
 
-	const prereqs = PREREQUISITE_ORDER[normalized] ?? [];
-	for (const prereq of prereqs) {
-		if (!(await fileExists(join(runRoot, prereq)))) {
-			errors.push(`${normalized}: prerequisite missing (${prereq})`);
-		}
+	if (doc) {
+		errors.push(...(await validatePlanningContextArtifact(normalized, doc)));
 	}
 
+	const prereqs = PREREQUISITE_ORDER[normalized] ?? [];
+	errors.push(
+		...(await validateArtifactPrerequisites(runRoot, normalized, prereqs)),
+	);
+
 	return { ok: errors.length === 0, errors };
 }
 

package/.pi/lib/harness-auto-commit-config.mjs

@@ -0,0 +1,321 @@
+/**
+ * Load and merge .pi/auto-commit.json (project overrides package).
+ * Format commit subjects and append Co-authored-by trailers.
+ */
+
+import { readFile, access } from "node:fs/promises";
+import { constants } from "node:fs";
+import { join } from "node:path";
+
+const TEMPLATE_PLACEHOLDERS = new Set(["type", "scope", "subject", "login", "email"]);
+
+const DEFAULT_CO_AUTHOR = {
+	login: "pi-mono",
+	email: "261679550+pi-mono@users.noreply.github.com",
+	required: true,
+};
+
+const DEFAULT_MESSAGE = {
+	template: "{type}({scope}): {subject}",
+	templateNoScope: "{type}: {subject}",
+	typeDefault: "chore",
+	scopeDefault: "harness",
+	bodySeparator: "\n\n",
+	coAuthorTrailer: "Co-authored-by: {login} <{email}>",
+	maxSubjectLength: 72,
+};
+
+/** @param {unknown} value */
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Deep-merge objects; arrays and scalars from override replace base.
+ * @param {Record<string, unknown>} base
+ * @param {Record<string, unknown>} override
+ */
+export function deepMerge(base, override) {
+	const out = { ...base };
+	for (const [key, val] of Object.entries(override)) {
+		if (
+			isPlainObject(val) &&
+			isPlainObject(out[key]) &&
+			!Array.isArray(val)
+		) {
+			out[key] = deepMerge(
+				/** @type {Record<string, unknown>} */ (out[key]),
+				/** @type {Record<string, unknown>} */ (val),
+			);
+		} else {
+			out[key] = val;
+		}
+	}
+	return out;
+}
+
+async function readJsonIfExists(path) {
+	try {
+		await access(path, constants.R_OK);
+	} catch {
+		return null;
+	}
+	const raw = await readFile(path, "utf-8");
+	return JSON.parse(raw);
+}
+
+/**
+ * @param {string} template
+ */
+export function assertValidTemplate(template) {
+	const re = /\{([a-zA-Z_]+)\}/g;
+	let m;
+	while ((m = re.exec(template)) !== null) {
+		if (!TEMPLATE_PLACEHOLDERS.has(m[1])) {
+			throw new Error(
+				`auto-commit: unknown placeholder {${m[1]}} in template (allowed: ${[...TEMPLATE_PLACEHOLDERS].join(", ")})`,
+			);
+		}
+	}
+}
+
+/**
+ * @param {Record<string, unknown>} config
+ */
+export function validateAutoCommitConfig(config) {
+	const coAuthor = /** @type {Record<string, unknown>} */ (
+		config.coAuthor ?? {}
+	);
+	const login = coAuthor.login;
+	const email = coAuthor.email;
+	if (typeof login !== "string" || !login.trim()) {
+		throw new Error("auto-commit: coAuthor.login is required");
+	}
+	if (typeof email !== "string" || !email.trim() || !email.includes("@")) {
+		throw new Error("auto-commit: coAuthor.email must be a valid email");
+	}
+
+	const message = /** @type {Record<string, unknown>} */ (
+		config.message ?? {}
+	);
+	const template = message.template;
+	if (typeof template !== "string" || !template.trim()) {
+		throw new Error("auto-commit: message.template is required");
+	}
+	assertValidTemplate(template);
+	const templateNoScope = message.templateNoScope;
+	if (templateNoScope != null) {
+		if (typeof templateNoScope !== "string" || !templateNoScope.trim()) {
+			throw new Error("auto-commit: message.templateNoScope must be non-empty");
+		}
+		assertValidTemplate(templateNoScope);
+	}
+	const trailer = message.coAuthorTrailer;
+	if (typeof trailer !== "string" || !trailer.trim()) {
+		throw new Error("auto-commit: message.coAuthorTrailer is required");
+	}
+	assertValidTemplate(trailer);
+}
+
+/**
+ * @param {string} projectRoot
+ * @param {string} upPkg
+ */
+export async function resolveAutoCommitConfig(projectRoot, upPkg) {
+	const pkgPath = join(upPkg, ".pi", "auto-commit.json");
+	const projectPath = join(projectRoot, ".pi", "auto-commit.json");
+
+	const pkgRaw = (await readJsonIfExists(pkgPath)) ?? {};
+	const projectRaw = (await readJsonIfExists(projectPath)) ?? {};
+
+	const base = {
+		dryRun: false,
+		coAuthor: { ...DEFAULT_CO_AUTHOR },
+		message: { ...DEFAULT_MESSAGE },
+		...(isPlainObject(pkgRaw) ? pkgRaw : {}),
+	};
+	const merged = deepMerge(
+		/** @type {Record<string, unknown>} */ (base),
+		/** @type {Record<string, unknown>} */ (
+			isPlainObject(projectRaw) ? projectRaw : {}
+		),
+	);
+
+	if (!isPlainObject(merged.message)) {
+		merged.message = { ...DEFAULT_MESSAGE };
+	} else {
+		merged.message = { ...DEFAULT_MESSAGE, ...merged.message };
+	}
+	if (!isPlainObject(merged.coAuthor)) {
+		merged.coAuthor = { ...DEFAULT_CO_AUTHOR };
+	} else {
+		merged.coAuthor = { ...DEFAULT_CO_AUTHOR, ...merged.coAuthor };
+	}
+
+	validateAutoCommitConfig(merged);
+	return merged;
+}
+
+/**
+ * @param {string} template
+ * @param {Record<string, string>} vars
+ */
+function applyTemplate(template, vars) {
+	return template.replace(/\{([a-zA-Z_]+)\}/g, (_, key) => vars[key] ?? "");
+}
+
+/**
+ * @param {Record<string, unknown>} config
+ * @param {{ type?: string, scope?: string, subject: string, body?: string }} input
+ */
+export function formatCommitMessage(config, input) {
+	const message = /** @type {Record<string, unknown>} */ (config.message);
+	const type =
+		(input.type ?? message.typeDefault ?? "chore").toString().trim() ||
+		"chore";
+	let scope = (input.scope ?? message.scopeDefault ?? "").toString().trim();
+	const subject = input.subject.trim();
+	if (!subject) {
+		throw new Error("auto-commit: subject is required");
+	}
+
+	const maxLen =
+		typeof message.maxSubjectLength === "number"
+			? message.maxSubjectLength
+			: 72;
+	let subjectLine = subject.split(/\r?\n/)[0] ?? subject;
+	if (subjectLine.length > maxLen) {
+		subjectLine = `${subjectLine.slice(0, maxLen - 3)}...`;
+	}
+
+	const template =
+		scope.length > 0
+			? String(message.template)
+			: String(message.templateNoScope ?? message.template);
+	const subjectFormatted = applyTemplate(template, {
+		type,
+		scope,
+		subject: subjectLine,
+	});
+
+	const body = (input.body ?? "").trim();
+	const bodySep = String(message.bodySeparator ?? "\n\n");
+	if (!body) {
+		return subjectFormatted;
+	}
+	return `${subjectFormatted}${bodySep}${body}`;
+}
+
+/**
+ * Strip trailing co-authored-by lines from commit message body.
+ * @param {string} message
+ */
+export function stripCoAuthorTrailers(message) {
+	const lines = message.replace(/\r\n/g, "\n").split("\n");
+	while (lines.length > 0) {
+		const last = lines[lines.length - 1]?.trim() ?? "";
+		if (!last) {
+			lines.pop();
+			continue;
+		}
+		if (/^co-authored-by:/i.test(last)) {
+			lines.pop();
+			continue;
+		}
+		break;
+	}
+	return lines.join("\n").trimEnd();
+}
+
+/**
+ * @param {Record<string, unknown>} coAuthor
+ * @param {string} trailerTemplate
+ */
+export function renderCoAuthorTrailer(coAuthor, trailerTemplate) {
+	return applyTemplate(trailerTemplate, {
+		login: String(coAuthor.login).trim(),
+		email: String(coAuthor.email).trim(),
+		type: "",
+		scope: "",
+		subject: "",
+	});
+}
+
+/**
+ * @param {string} message
+ * @param {Record<string, unknown>} coAuthor
+ * @param {string} trailerTemplate
+ */
+export function messageHasCoAuthorTrailer(message, coAuthor, trailerTemplate) {
+	const expected = renderCoAuthorTrailer(coAuthor, trailerTemplate)
+		.trim()
+		.toLowerCase();
+	const normalized = message.replace(/\r\n/g, "\n").toLowerCase();
+	return normalized.includes(expected);
+}
+
+/**
+ * @param {string} message
+ * @param {Record<string, unknown>} config
+ */
+export function appendCoAuthorTrailer(message, config) {
+	const coAuthor = /** @type {Record<string, unknown>} */ (config.coAuthor);
+	const messageCfg = /** @type {Record<string, unknown>} */ (config.message);
+	const trailerTemplate = String(
+		messageCfg.coAuthorTrailer ?? DEFAULT_MESSAGE.coAuthorTrailer,
+	);
+
+	if (coAuthor.required === false) {
+		return message;
+	}
+
+	const stripped = stripCoAuthorTrailers(message);
+	if (messageHasCoAuthorTrailer(stripped, coAuthor, trailerTemplate)) {
+		return stripped;
+	}
+
+	const trailer = renderCoAuthorTrailer(coAuthor, trailerTemplate);
+	if (!stripped) {
+		return trailer;
+	}
+	return `${stripped}\n\n${trailer}`;
+}
+
+/**
+ * Build final commit message (subject/body + trailer).
+ * @param {Record<string, unknown>} config
+ * @param {{ type?: string, scope?: string, subject?: string, body?: string, message?: string }} input
+ */
+export function buildFullCommitMessage(config, input) {
+	let core;
+	if (input.message != null && String(input.message).trim()) {
+		core = String(input.message).trim();
+	} else if (input.subject != null && String(input.subject).trim()) {
+		core = formatCommitMessage(config, {
+			type: input.type,
+			scope: input.scope,
+			subject: String(input.subject),
+			body: input.body,
+		});
+	} else {
+		throw new Error(
+			"auto-commit: provide --message or --subject for commit text",
+		);
+	}
+	return appendCoAuthorTrailer(core, config);
+}
+
+/** @param {string} message */
+export function splitSubjectAndBody(message) {
+	const normalized = message.replace(/\r\n/g, "\n");
+	const idx = normalized.indexOf("\n\n");
+	if (idx === -1) {
+		return { subject: normalized.trim(), body: "" };
+	}
+	return {
+		subject: normalized.slice(0, idx).trim(),
+		body: normalized.slice(idx + 2).trim(),
+	};
+}
+
+export { DEFAULT_CO_AUTHOR, DEFAULT_MESSAGE, TEMPLATE_PLACEHOLDERS };

package/.pi/lib/harness-lens/clients/anchored-edit-autopatch.ts

@@ -0,0 +1,158 @@
+import * as nodeFs from "node:fs";
+import { AnchorStateManager } from "../../harness-anchored-edit/anchor-state.js";
+import { EditExecutor } from "../../harness-anchored-edit/edit-executor.js";
+import { splitAnchor } from "../../harness-anchored-edit/line-protocol.js";
+import type { AnchoredEdit } from "../../harness-anchored-edit/types.js";
+import { tryCorrectIndentationMismatchFromContent } from "./edit-autopatch.js";
+import { retargetReplacementIndentation } from "./indent-retarget.js";
+
+function leadingIndent(line: string): string {
+	return line.match(/^[\t ]*/)?.[0] ?? "";
+}
+
+function isIndentationOnlyChange(before: string, after: string): boolean {
+	const beforeLines = before.replace(/\r\n/g, "\n").split("\n");
+	const afterLines = after.replace(/\r\n/g, "\n").split("\n");
+	if (beforeLines.length !== afterLines.length) return false;
+	return beforeLines.every(
+		(line, index) => line.trim() === afterLines[index].trim(),
+	);
+}
+
+type AnchoredEditInput = {
+	edits?: AnchoredEdit[];
+};
+
+export function isAnchoredEditToolInput(
+	editInput: unknown,
+): editInput is AnchoredEditInput {
+	if (!editInput || typeof editInput !== "object") return false;
+	const edits = (editInput as AnchoredEditInput).edits;
+	if (!Array.isArray(edits) || edits.length === 0) return false;
+	return typeof edits[0]?.anchor === "string";
+}
+
+/**
+ * Indentation-only correction for harness anchored edit.text before apply.
+ */
+export function applyAnchoredEditAutopatch(
+	filePath: string,
+	editInput: AnchoredEditInput,
+	taskId: string,
+): { block: true; reason: string } | undefined {
+	const edits = editInput.edits;
+	if (!edits?.length) return undefined;
+
+	let crlfContent: string;
+	try {
+		crlfContent = nodeFs.readFileSync(filePath, "utf-8").replace(/\r\n/g, "\n");
+	} catch {
+		return undefined;
+	}
+
+	const lines = crlfContent.split("\n");
+	const lineAnchors = AnchorStateManager.reconcile(filePath, lines, taskId);
+	const executor = new EditExecutor();
+	const { resolvedEdits, failedEdits } = executor.resolveEdits(
+		edits,
+		lines,
+		lineAnchors,
+	);
+	if (failedEdits.length > 0) return undefined;
+
+	const corrected: Array<{
+		label: string;
+		original: string;
+		corrected: string;
+		indentationOnly: boolean;
+		apply: (value: string) => void;
+	}> = [];
+
+	for (const { lineIdx, endIdx, edit } of resolvedEdits) {
+		const editType = edit.edit_type ?? "replace";
+		const text = edit.text ?? "";
+		if (!text.trim()) continue;
+
+		let referenceBlock: string;
+		if (editType === "replace") {
+			referenceBlock = lines.slice(lineIdx, endIdx + 1).join("\n");
+		} else {
+			referenceBlock = lines[lineIdx] ?? "";
+		}
+
+		const correctedText = tryCorrectIndentationMismatchFromContent(
+			text,
+			crlfContent,
+		);
+		if (correctedText === undefined) {
+			const refIndent = leadingIndent(referenceBlock.split("\n")[0] ?? "");
+			const textIndent = leadingIndent(text.split("\n")[0] ?? "");
+			if (
+				refIndent !== textIndent &&
+				isIndentationOnlyChange(
+					textIndent + text.trimStart(),
+					refIndent + text.trimStart(),
+				)
+			) {
+				const retargeted = retargetReplacementIndentation(
+					text,
+					textIndent + text.trimStart(),
+					refIndent + text.trimStart(),
+				);
+				if (retargeted !== undefined) {
+					corrected.push({
+						label: `edits anchor ${splitAnchor(edit.anchor).anchor}`,
+						original: text,
+						corrected: retargeted,
+						indentationOnly: true,
+						apply: (value) => {
+							edit.text = value;
+						},
+					});
+				}
+			}
+			continue;
+		}
+
+		if (correctedText !== text) {
+			const retargeted = retargetReplacementIndentation(
+				text,
+				text,
+				correctedText,
+			);
+			corrected.push({
+				label: `edits anchor ${splitAnchor(edit.anchor).anchor}`,
+				original: text,
+				corrected: retargeted ?? correctedText,
+				indentationOnly: isIndentationOnlyChange(text, correctedText),
+				apply: (value) => {
+					edit.text = value;
+				},
+			});
+		}
+	}
+
+	if (corrected.length === 0) return undefined;
+
+	const unsafe = corrected.filter((entry) => !entry.indentationOnly);
+	if (unsafe.length > 0) {
+		const details = unsafe
+			.map(({ label, original }) => {
+				const preview = original.trimStart().slice(0, 60).replace(/\n/g, "↵");
+				return `${label} ("${preview}…") cannot be auto-patched (not indentation-only).`;
+			})
+			.join("\n");
+		return {
+			block: true,
+			reason:
+				`🔄 RETRYABLE — Indentation mismatch on anchored edit text\n\n` +
+				`${details}\n\n` +
+				`Next action: re-read the relevant section, then retry with text matching file indentation.`,
+		};
+	}
+
+	for (const entry of corrected) {
+		entry.apply(entry.corrected);
+	}
+	return undefined;
+}