pi-posthorse 0.10.2 → 0.10.3

package/src/recovery-notes.ts

@@ -1,455 +1,25 @@
-import {
-	isRecord,
-	optionalString,
-	type EntryLike,
-	type MessageLike,
-	type ProjectedEntry,
-	type ToolCallLike,
-} from "./contracts.ts";
+import type { EntryLike, ProjectedEntry } from "./contracts.ts";
 import { contextEdits } from "./history-entries.ts";
-import { textOf, toolCalls } from "./message-text.ts";
+import {
+	collectTouches,
+	type ScannedNoteEntry,
+	type NoteTarget,
+	type NoteTouch,
+} from "./recovery-note-touches.ts";
 
 const MAX_WRITTEN_NOTES = 4;
 const MAX_READ_NOTES = 3;
 
-type ScannedNoteEntry = {
-	readonly entry: EntryLike;
-	readonly entryId: string;
-	readonly inRetained: boolean;
-};
 export type RetainedSpan = { readonly firstId: string; readonly lastId: string };
-type NoteOpKind = "full-write" | "partial-write" | "read" | "clear";
-type NoteTarget = { readonly notePath: string; readonly absPath?: string };
-type NoteTouch = NoteTarget & {
-	readonly kind: NoteOpKind;
-	readonly entryId: string;
-	readonly inRetained: boolean;
-};
 type TrackedNote = NoteTarget & {
 	readonly written: boolean;
 	readonly lastEntryId: string;
 	readonly lastInRetained: boolean;
-	readonly lastWriteEntryId?: string;
-	readonly fullWriteRetainedEntryId?: string;
-	readonly partialEditRetainedEntryId?: string;
+	readonly lastWriteEntryId?: string | undefined;
+	readonly fullWriteRetainedEntryId?: string | undefined;
+	readonly partialEditRetainedEntryId?: string | undefined;
 	readonly order: number;
 };
-type ToolResultInfo = {
-	readonly entryId: string;
-	readonly inRetained: boolean;
-	readonly isError: boolean;
-	readonly toolName: string;
-	readonly text: string;
-	readonly details: unknown;
-};
-type TouchContext = {
-	readonly entryId: string;
-	readonly inRetained: boolean;
-	readonly knownDirs: ReadonlySet<string>;
-};
-
-function bareToolName(name: string | undefined): string {
-	if (name === undefined || name === "") {
-		return "";
-	}
-	const cut = Math.max(name.lastIndexOf(":"), name.lastIndexOf("/"));
-	return cut >= 0 ? name.slice(cut + 1) : name;
-}
-
-function normalizeRelPath(raw: string): string {
-	const cleaned = raw
-		.trim()
-		.replaceAll("\\", "/")
-		.replace(/^(?:\.\/)+/u, "")
-		.replace(/^\/+/u, "");
-	const invalid =
-		cleaned === "" ||
-		cleaned === "." ||
-		cleaned === ".." ||
-		cleaned.startsWith("../") ||
-		cleaned.includes("/../") ||
-		cleaned.endsWith("/");
-	return invalid ? "" : cleaned;
-}
-
-function matchMarkerPath(slash: string): string | undefined {
-	for (const marker of ["/.pi/notes/", "/posthorse-notes/"]) {
-		const idx = slash.lastIndexOf(marker);
-		if (idx >= 0) {
-			return slash.slice(idx + marker.length);
-		}
-	}
-	if (slash.startsWith(".pi/notes/") || slash.startsWith("./.pi/notes/")) {
-		return slash.replace(/^(?:\.\/)?\.pi\/notes\//u, "");
-	}
-	const pkgMatch = /\/\.pi\/package-notes\/[0-9a-f]{64}\/notes\/(.+)$/u.exec(slash);
-	if (pkgMatch !== null) {
-		return pkgMatch[1];
-	}
-	return /\/\.pi\/(?:agent\/)?notes\/[^/]+\/[^/]+\/[^/]+\/(.+)$/u.exec(slash)?.[1];
-}
-
-function matchKnownDir(slash: string, knownDirs: ReadonlySet<string>): string | undefined {
-	for (const dir of knownDirs) {
-		if (slash.startsWith(`${dir}/`)) {
-			return slash.slice(dir.length + 1);
-		}
-	}
-	return undefined;
-}
-
-function resolveNoteTarget(
-	rawPath: string | undefined,
-	knownDirs: ReadonlySet<string>,
-	fromNotesTool: boolean,
-): NoteTarget | undefined {
-	if (rawPath === undefined) {
-		return undefined;
-	}
-	const trimmed = rawPath.trim();
-	const slash = trimmed.replaceAll("\\", "/");
-	const matched = matchKnownDir(slash, knownDirs) ?? matchMarkerPath(slash);
-	if (matched !== undefined) {
-		const rel = normalizeRelPath(matched);
-		return rel === "" ? undefined : { notePath: rel, absPath: trimmed };
-	}
-	if (!fromNotesTool) {
-		return undefined;
-	}
-	if (slash.startsWith("/") || /^[A-Za-z]:\//u.test(slash)) {
-		const base = normalizeRelPath(slash.slice(slash.lastIndexOf("/") + 1));
-		return base === "" ? undefined : { notePath: base, absPath: trimmed };
-	}
-	const rel = normalizeRelPath(slash);
-	return rel === "" ? undefined : { notePath: rel };
-}
-
-function extractNotesResultTarget(
-	text: string,
-): { readonly kind: NoteOpKind; readonly rawPath: string } | undefined {
-	const patterns: readonly (readonly [RegExp, NoteOpKind])[] = [
-		[/^Wrote ([^\r\n]+)$/mu, "full-write"],
-		[/^Appended to ([^\r\n]+)$/mu, "partial-write"],
-		[/^File: ([^\r\n]+)$/mu, "read"],
-	];
-	for (const [pattern, kind] of patterns) {
-		const match = pattern.exec(text);
-		if (match !== null) {
-			return { kind, rawPath: match[1] };
-		}
-	}
-	return undefined;
-}
-
-function collectResultMap(
-	entries: readonly ScannedNoteEntry[],
-): ReadonlyMap<string, ToolResultInfo> {
-	const results = new Map<string, ToolResultInfo>();
-	for (const item of entries) {
-		const msg = item.entry.message;
-		const callId = optionalString(msg?.toolCallId);
-		if (
-			item.entry.type === "message" &&
-			msg?.role === "toolResult" &&
-			callId !== undefined &&
-			callId !== ""
-		) {
-			results.set(callId, {
-				entryId: item.entryId,
-				inRetained: item.inRetained,
-				isError: msg.isError === true,
-				toolName: bareToolName(msg.toolName),
-				text: textOf(msg),
-				details: msg.details,
-			});
-		}
-	}
-	return results;
-}
-
-function inferDirFromCall(
-	call: ToolCallLike,
-	results: ReadonlyMap<string, ToolResultInfo>,
-): string | undefined {
-	const callId = optionalString(call.id);
-	const res = callId === undefined ? undefined : results.get(callId);
-	if (res === undefined || res.isError) {
-		return undefined;
-	}
-	const parsed = extractNotesResultTarget(res.text);
-	const rawCallPath = isRecord(call.arguments) ? optionalString(call.arguments.path) : undefined;
-	const callPath = rawCallPath === undefined ? "" : normalizeRelPath(rawCallPath);
-	if (parsed === undefined || callPath === "") {
-		return undefined;
-	}
-	const slash = parsed.rawPath.trim().replaceAll("\\", "/");
-	const suffix = `/${callPath}`;
-	return slash.endsWith(suffix) && slash.length > suffix.length
-		? slash.slice(0, slash.length - suffix.length)
-		: undefined;
-}
-
-function assistantCallsOf(entry: EntryLike): readonly ToolCallLike[] {
-	return entry.type === "message" && entry.message?.role === "assistant"
-		? toolCalls(entry.message.content)
-		: [];
-}
-
-function learnNotesDirs(
-	entries: readonly ScannedNoteEntry[],
-	results: ReadonlyMap<string, ToolResultInfo>,
-): ReadonlySet<string> {
-	const dirs = new Set<string>();
-	for (const info of results.values()) {
-		const match =
-			!info.isError && info.toolName === "notes"
-				? /^Notes directory: ([^\r\n]+)$/mu.exec(info.text)
-				: null;
-		if (match !== null) {
-			dirs.add(match[1].trim().replaceAll("\\", "/").replace(/\/+$/u, ""));
-		}
-	}
-	for (const item of entries) {
-		for (const call of assistantCallsOf(item.entry)) {
-			const inferred = inferDirFromCall(call, results);
-			if (inferred !== undefined) {
-				dirs.add(inferred);
-			}
-		}
-	}
-	return dirs;
-}
-
-function pathsFromFileList(value: unknown): string[] {
-	if (!Array.isArray(value)) {
-		return [];
-	}
-	return value.flatMap((item: unknown) => {
-		if (typeof item === "string") {
-			return [item];
-		}
-		const itemPath = isRecord(item) ? optionalString(item.path) : undefined;
-		const skipped =
-			isRecord(item) && (item.status === "failed" || item.status === "unattempted");
-		return itemPath !== undefined && !skipped ? [itemPath] : [];
-	});
-}
-
-function patchPaths(input: unknown): string[] {
-	return typeof input === "string"
-		? Array.from(
-				input.matchAll(/^\*\*\* (?:Update File|Add File|Move to): ([^\r\n]+)$/gmu),
-				(m) => m[1],
-			)
-		: [];
-}
-
-function detailFilePaths(details: unknown): string[] {
-	return isRecord(details)
-		? [...pathsFromFileList(details.modifiedFiles), ...pathsFromFileList(details.files)]
-		: [];
-}
-
-function extractFileToolSpec(
-	tool: string,
-	args: Readonly<Record<string, unknown>>,
-	details: unknown,
-): { readonly kind: NoteOpKind; readonly rawPaths: readonly string[] } | undefined {
-	if (args.preview === true) {
-		return undefined;
-	}
-	const directPath = optionalString(args.path);
-	const directKinds: Readonly<Record<string, NoteOpKind | undefined>> = {
-		write: args.content === "" ? "clear" : "full-write",
-		edit: "partial-write",
-		read: "read",
-	};
-	const directKind = directKinds[tool];
-	if (directKind !== undefined && directPath !== undefined) {
-		return { kind: directKind, rawPaths: [directPath] };
-	}
-	if (tool === "write_files" || tool === "replace_text") {
-		const kind: NoteOpKind = tool === "write_files" ? "full-write" : "partial-write";
-		return { kind, rawPaths: [...pathsFromFileList(args.files), ...detailFilePaths(details)] };
-	}
-	return tool === "apply_patch"
-		? {
-				kind: "partial-write",
-				rawPaths: [...patchPaths(args.input), ...detailFilePaths(details)],
-			}
-		: undefined;
-}
-
-function fileToolTouches(
-	tool: string,
-	args: Readonly<Record<string, unknown>>,
-	details: unknown,
-	context: TouchContext,
-): NoteTouch[] {
-	const spec = extractFileToolSpec(tool, args, details);
-	if (spec === undefined) {
-		return [];
-	}
-	return spec.rawPaths.flatMap((raw) => {
-		const target = resolveNoteTarget(raw, context.knownDirs, false);
-		return target === undefined
-			? []
-			: [
-					{
-						...target,
-						kind: spec.kind,
-						entryId: context.entryId,
-						inRetained: context.inRetained,
-					},
-				];
-	});
-}
-
-function notesCallKind(args: Readonly<Record<string, unknown>>): NoteOpKind | undefined {
-	if (args.op === "write") {
-		return args.content === "" ? "clear" : "full-write";
-	}
-	if (args.op === "append") {
-		return "partial-write";
-	}
-	return args.op === "read" ? "read" : undefined;
-}
-
-function mergeNoteTargets(
-	callTarget: NoteTarget | undefined,
-	resTarget: NoteTarget | undefined,
-): NoteTarget | undefined {
-	const notePath = callTarget?.notePath ?? resTarget?.notePath;
-	return notePath === undefined
-		? undefined
-		: { notePath, absPath: resTarget?.absPath ?? callTarget?.absPath };
-}
-
-function notesToolTouches(
-	args: Readonly<Record<string, unknown>>,
-	resultText: string | undefined,
-	context: TouchContext,
-): NoteTouch[] {
-	const parsed = resultText === undefined ? undefined : extractNotesResultTarget(resultText);
-	const kind = notesCallKind(args) ?? parsed?.kind;
-	const callTarget = resolveNoteTarget(optionalString(args.path), context.knownDirs, true);
-	const resTarget = resolveNoteTarget(parsed?.rawPath, context.knownDirs, true);
-	const merged = mergeNoteTargets(callTarget, resTarget);
-	return kind === undefined || merged === undefined
-		? []
-		: [{ ...merged, kind, entryId: context.entryId, inRetained: context.inRetained }];
-}
-
-function extractNestedCalls(message: MessageLike): readonly unknown[] {
-	const nested = isRecord(message.nestedCalls) ? message.nestedCalls.calls : undefined;
-	if (Array.isArray(nested)) {
-		return nested;
-	}
-	const details = isRecord(message.details) ? message.details : undefined;
-	if (details !== undefined && Array.isArray(details.calls)) {
-		return details.calls;
-	}
-	const detailNested =
-		details !== undefined && isRecord(details.nestedCalls)
-			? details.nestedCalls.calls
-			: undefined;
-	return Array.isArray(detailNested) ? detailNested : [];
-}
-
-function nestedArgs(raw: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> {
-	if (isRecord(raw.arguments)) {
-		return raw.arguments;
-	}
-	if (isRecord(raw.args)) {
-		return raw.args;
-	}
-	return isRecord(raw.input) ? raw.input : {};
-}
-
-function touchesFromNested(message: MessageLike, context: TouchContext): NoteTouch[] {
-	return extractNestedCalls(message).flatMap((raw) => {
-		if (
-			!isRecord(raw) ||
-			raw.isError === true ||
-			raw.status === "error" ||
-			(typeof raw.error === "string" && raw.error !== "")
-		) {
-			return [];
-		}
-		const name = bareToolName(optionalString(raw.name) ?? optionalString(raw.toolName));
-		const args = nestedArgs(raw);
-		return name === "notes"
-			? notesToolTouches(args, optionalString(raw.result), context)
-			: fileToolTouches(name, args, raw.result, context);
-	});
-}
-
-function touchesFromAssistantCall(
-	call: ToolCallLike,
-	results: ReadonlyMap<string, ToolResultInfo>,
-	context: TouchContext,
-): { readonly consumedCallId?: string; readonly touches: readonly NoteTouch[] } {
-	const callId = optionalString(call.id);
-	const res = callId === undefined ? undefined : results.get(callId);
-	const consumedCallId = callId !== undefined && res !== undefined ? callId : undefined;
-	if (res?.isError === true) {
-		return { consumedCallId, touches: [] };
-	}
-	const tool = bareToolName(call.name);
-	const args = isRecord(call.arguments) ? call.arguments : {};
-	const touches =
-		tool === "notes"
-			? notesToolTouches(args, res?.text, context)
-			: fileToolTouches(tool, args, res?.details, context);
-	return { consumedCallId, touches };
-}
-
-function touchesFromToolResult(
-	msg: MessageLike,
-	handledResultIds: ReadonlySet<string>,
-	context: TouchContext,
-): NoteTouch[] {
-	if (msg.role !== "toolResult" || msg.isError === true) {
-		return [];
-	}
-	const callId = optionalString(msg.toolCallId) ?? "";
-	const direct =
-		!handledResultIds.has(callId) && bareToolName(msg.toolName) === "notes"
-			? notesToolTouches({}, textOf(msg), context)
-			: [];
-	return [...direct, ...touchesFromNested(msg, context)];
-}
-
-function collectTouches(entries: readonly ScannedNoteEntry[]): {
-	readonly touches: readonly NoteTouch[];
-	readonly defaultDir?: string;
-} {
-	const results = collectResultMap(entries);
-	const knownDirs = learnNotesDirs(entries, results);
-	const handledResultIds = new Set<string>();
-	const touches: NoteTouch[] = [];
-	for (const item of entries) {
-		const msg = item.entry.message;
-		const context: TouchContext = {
-			entryId: item.entryId,
-			inRetained: item.inRetained,
-			knownDirs,
-		};
-		for (const call of assistantCallsOf(item.entry)) {
-			const out = touchesFromAssistantCall(call, results, context);
-			if (out.consumedCallId !== undefined) {
-				handledResultIds.add(out.consumedCallId);
-			}
-			touches.push(...out.touches);
-		}
-		if (item.entry.type === "message" && msg !== undefined) {
-			touches.push(...touchesFromToolResult(msg, handledResultIds, context));
-		}
-	}
-	const defaultDir = knownDirs.size === 1 ? [...knownDirs][0] : undefined;
-	return { touches, defaultDir };
-}
-
 function applyReadTouch(
 	previous: TrackedNote | undefined,
 	touch: NoteTouch,

package/src/recovery-records.ts

@@ -0,0 +1,90 @@
+import { isReminderType, type EntryLike } from "./contracts.ts";
+import { boundedBlock, imageSummary, imagesOf, textOf } from "./message-text.ts";
+
+export type RecoveryRecord = {
+	readonly id: string;
+	readonly timestamp: string;
+	readonly kind: "owner" | "coordination";
+	readonly label: string;
+	readonly text: string;
+};
+type RecordSource = {
+	readonly kind: RecoveryRecord["kind"];
+	readonly label: string;
+	readonly content: unknown;
+};
+function ownerAnswer(entry: EntryLike, ownerQuestion: boolean): boolean {
+	const message = entry.message;
+	return (
+		ownerQuestion &&
+		entry.type === "message" &&
+		message?.role === "toolResult" &&
+		message.toolName === "ask_question" &&
+		message.namespace === undefined &&
+		message.isError !== true
+	);
+}
+function recordSource(entry: EntryLike, ownerQuestion: boolean): RecordSource | undefined {
+	if (entry.type === "message" && entry.message?.role === "user") {
+		return { kind: "owner", label: "owner input", content: entry.message.content };
+	}
+	if (ownerAnswer(entry, ownerQuestion)) {
+		return {
+			kind: "owner",
+			label: "owner answer via ask_question",
+			content: entry.message?.content,
+		};
+	}
+	if (
+		entry.type === "custom_message" &&
+		entry.display === true &&
+		!isReminderType(entry.customType)
+	) {
+		return {
+			kind: "coordination",
+			label: `visible ${(entry.customType ?? "custom").slice(0, 80)} coordination input (not direct owner input)`,
+			content: entry.content,
+		};
+	}
+	return;
+}
+export function recoveryRecord(
+	entry: EntryLike,
+	ownerQuestion: boolean,
+): RecoveryRecord | undefined {
+	const source = recordSource(entry, ownerQuestion);
+	if (source === undefined) {
+		return undefined;
+	}
+	const id = entry.id?.slice(0, 120) ?? "unknown";
+	const text = textOf({ content: source.content }).trim();
+	const summary =
+		source.label === "owner answer via ask_question"
+			? ""
+			: imageSummary(imagesOf(source.content));
+	const body = [text, summary === "" ? "" : `${summary} — recover with history read id ${id}`]
+		.filter((part) => part !== "")
+		.join("\n");
+	return {
+		id,
+		timestamp: entry.timestamp?.slice(0, 80) ?? "unknown time",
+		kind: source.kind,
+		label: source.label,
+		text: body === "" ? "(non-text content; recover the entry from history)" : body,
+	};
+}
+export function formatRecord(record: RecoveryRecord, limit: number): string {
+	return boundedBlock(
+		`[${record.label} | ${record.timestamp} | entry ${record.id}]`,
+		record.text,
+		limit,
+	);
+}
+export function indexLine(record: RecoveryRecord): string {
+	const header = formatRecord(record, 0);
+	if (record.kind !== "owner") {
+		return header;
+	}
+	const preview = record.text.replace(/\s+/g, " ").trim();
+	return `${header} ${preview.length > 120 ? `${preview.slice(0, 119)}…` : preview}`;
+}

package/src/recovery-results.ts

@@ -10,9 +10,13 @@ import {
 } from "./message-text.ts";
 
 export type RecoveryEntry = EntryLike & { readonly retained: boolean };
+const INCOMPLETE_STOPS = new Set(["error", "aborted", "length"]);
 type LinkedCall = { readonly entry: EntryLike; readonly block: ToolCallLike };
 export type RecoveryBlock = { readonly header: string; readonly text: string };
-export type RecoveryBatch = { readonly callId?: string; readonly blocks: readonly RecoveryBlock[] };
+export type RecoveryBatch = {
+	readonly callId?: string | undefined;
+	readonly blocks: readonly RecoveryBlock[];
+};
 function callsById(entries: readonly EntryLike[]): Map<string, LinkedCall> {
 	const calls = new Map<string, LinkedCall>();
 	for (const entry of entries) {
@@ -30,14 +34,11 @@ function callsById(entries: readonly EntryLike[]): Map<string, LinkedCall> {
 function trailingStart(entries: readonly EntryLike[]): number {
 	let hasTrailingResult = false;
 	for (let i = entries.length - 1; i >= 0; i--) {
-		const message = entries[i].message;
+		const message = entries[i]?.message;
 		if (message?.role === "toolResult") {
 			hasTrailingResult = true;
 		} else if (message?.role === "assistant") {
-			const invalid =
-				message.stopReason === "error" ||
-				message.stopReason === "aborted" ||
-				message.stopReason === "length";
+			const invalid = INCOMPLETE_STOPS.has(message.stopReason ?? "");
 			if (!invalid || hasTrailingResult) {
 				return i;
 			}