@sgtbeatdown/pi-tasks 0.1.5 → 0.1.7

package/src/legacy-task-inbox.ts

@@ -1,148 +0,0 @@
-import type { TaskAssignment, TaskEvent, TaskStatus, WolfpackGatewayClient } from "./gateway-client";
-
-const TASK_EVENT_CUSTOM_TYPE = "wolfpack-task-event";
-const TASK_CURSOR_CUSTOM_TYPE = "wolfpack-task-cursor";
-
-interface InboxContext {
-	readonly hasPendingMessages: () => boolean;
-	readonly sessionManager: {
-		readonly buildContextEntries: () => readonly unknown[];
-		readonly getEntries: () => readonly unknown[];
-	};
-}
-
-interface InboxPi {
-	sendMessage(message: { readonly customType: string; readonly content: string; readonly display: boolean; readonly details: TaskEventDetails }, options: { readonly triggerTurn: true; readonly deliverAs: "followUp" }): void;
-	appendEntry(customType: string, data: { readonly cursor: string }): void;
-}
-
-interface TaskEventDetails {
-	readonly taskId: string;
-	readonly eventId: string;
-}
-
-interface InboxClient {
-	inbox(cursor: string, includeAcknowledged: boolean): Promise<{ readonly events: readonly TaskEvent[]; readonly nextCursor: string; readonly hasMore: boolean }>;
-	status(taskId: string): Promise<TaskStatus>;
-	delivered(taskId: string, eventId: string): Promise<unknown>;
-}
-
-export async function deliverTaskInbox(pi: InboxPi, client: InboxClient, ctx: InboxContext, initialCursor: string): Promise<string> {
-	if (ctx.hasPendingMessages()) return initialCursor;
-	const entries = ctx.sessionManager.getEntries();
-	const incorporated = incorporatedEvents(entries);
-	const includeAcknowledged = initialCursor === "0" && !hasPersistedCursor(entries);
-	let cursor = initialCursor;
-	for (;;) {
-		const page = await client.inbox(cursor, includeAcknowledged);
-		for (const event of page.events) {
-			const disposition = inboxDisposition(event.type);
-			if (disposition === "internal") continue;
-			if (disposition === "unknown") throw new Error(`unknown task inbox event type: ${event.type}`);
-			if (ctx.hasPendingMessages()) return cursor;
-			const eventKey = key(event.taskId, event.id);
-			const snapshot = await client.status(event.taskId);
-			if (ctx.hasPendingMessages()) return cursor;
-			if (incorporated.has(eventKey)) {
-				if (event.destination.sessionId === snapshot.task.target.sessionId) await client.delivered(event.taskId, event.id);
-				continue;
-			}
-			if (terminalHistoryAcknowledged(snapshot)) continue;
-			pi.sendMessage({
-				customType: TASK_EVENT_CUSTOM_TYPE,
-				content: renderTaskEvent(event, snapshot),
-				display: true,
-				details: { taskId: event.taskId, eventId: event.id },
-			}, { triggerTurn: true, deliverAs: "followUp" });
-			if (!incorporatedEvents(ctx.sessionManager.getEntries()).has(eventKey)) return cursor;
-			incorporated.add(eventKey);
-			if (event.destination.sessionId === snapshot.task.target.sessionId) await client.delivered(event.taskId, event.id);
-		}
-		// Inbox cursors are machine-local delivery sequences, never task event sequences.
-		cursor = page.nextCursor;
-		pi.appendEntry(TASK_CURSOR_CUSTOM_TYPE, { cursor });
-		if (!page.hasMore) return cursor;
-	}
-}
-
-function hasPersistedCursor(entries: readonly unknown[]): boolean {
-	return entries.some((entry) => isRecord(entry) && entry.type === "custom" && entry.customType === TASK_CURSOR_CUSTOM_TYPE && isRecord(entry.data) && decimal(entry.data.cursor));
-}
-
-function inboxDisposition(type: string): "model-visible" | "internal" | "unknown" {
-	if (type === "task.created" || type === "task.question" || type === "task.answer" || type === "task.information" || terminalEvent(type) || type === "task.cancel_requested") return "model-visible";
-	if (type === "task.received" || type === "task.receipt_confirmed" || type === "task.delivered" || type === "message.delivered" || type === "task.parent_ack_pending" || type === "task.parent_acknowledged" || type === "event.delivery_failed" || type === "task.late_terminal") return "internal";
-	return "unknown";
-}
-
-function terminalHistoryAcknowledged(snapshot: TaskStatus): boolean {
-	return ["completed", "failed", "cancelled", "timed_out"].includes(snapshot.status) && snapshot.events.some((event) => event.type === "task.parent_acknowledged");
-}
-
-export function restoredInboxCursor(entries: readonly unknown[]): string {
-	let cursor = "0";
-	for (const entry of entries) {
-		if (!isRecord(entry) || entry.type !== "custom" || entry.customType !== TASK_CURSOR_CUSTOM_TYPE || !isRecord(entry.data) || !decimal(entry.data.cursor)) continue;
-		cursor = entry.data.cursor;
-	}
-	return cursor;
-}
-
-export function incorporatedEvents(entries: readonly unknown[]): Set<string> {
-	const events = new Set<string>();
-	for (const entry of entries) {
-		if (!isRecord(entry) || entry.type !== "custom_message" || entry.customType !== TASK_EVENT_CUSTOM_TYPE || !isRecord(entry.details) || !nonEmpty(entry.details.taskId) || !nonEmpty(entry.details.eventId)) continue;
-		events.add(key(entry.details.taskId, entry.details.eventId));
-	}
-	return events;
-}
-
-export function renderTaskEvent(event: TaskEvent, snapshot: TaskStatus): string {
-	const header = `task: \`${event.taskId}\` · event: \`${event.id}\``;
-	if (event.type === "task.created") return renderAssignment(header, snapshot.task, snapshot.warnings);
-	const message = event.message ? `\n\n${event.message}` : "";
-	const completion = event.completion ?? snapshot.completion;
-	const completionText = completion ? `\n\n**summary:** ${completion.summary}` : "";
-	const parentPrompt = terminalEvent(event.type) && event.destination.sessionId === snapshot.task.source.sessionId && snapshot.task.onCompletePrompt
-		? `\n\n## parent follow-up\n${snapshot.task.onCompletePrompt}`
-		: "";
-	const warnings = renderWarnings(snapshot.warnings);
-	return `## task ${label(event.type)}\n${header}${message}${completionText}${parentPrompt}${warnings}`;
-}
-
-function renderAssignment(header: string, assignment: TaskAssignment, warnings: readonly { readonly code: string; readonly message: string }[]): string {
-	const role = assignment.role ? `\n\n## role\n${assignment.role}` : "";
-	const context = assignment.context?.summary ? `\n\n## context\n${assignment.context.summary}` : "";
-	const refs = assignment.context?.refs?.length
-		? `\n\n## selected refs\n${assignment.context.refs.map((ref) => `- \`${ref.path}\`${ref.selector ? ` — ${ref.selector}` : ""}${ref.purpose ? ` — ${ref.purpose}` : ""}`).join("\n")}`
-		: "";
-	return `## task assignment\n${header}\n\n${assignment.task}${role}${context}${refs}${renderWarnings(warnings)}`;
-}
-
-function renderWarnings(warnings: readonly { readonly code: string; readonly message: string }[]): string {
-	return warnings.length === 0 ? "" : `\n\n## gateway warnings\n${warnings.map((warning) => `- ${warning.code}: ${warning.message}`).join("\n")}`;
-}
-
-function label(type: string): string {
-	return type.replace(/^task\./, "").replaceAll("_", " ");
-}
-
-function terminalEvent(type: string): boolean {
-	return type === "task.completed" || type === "task.failed" || type === "task.cancelled" || type === "task.timed_out";
-}
-
-function key(taskId: string, eventId: string): string {
-	return `${taskId}\u0000${eventId}`;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function nonEmpty(value: unknown): value is string {
-	return typeof value === "string" && value.length > 0;
-}
-
-function decimal(value: unknown): value is string {
-	return typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value);
-}

package/src/metrics-cli.ts

@@ -1,20 +0,0 @@
-import { analyzeTaskStoreMetrics } from "./metrics";
-import { buildTaskBoard } from "./task-board";
-
-export async function runTaskMetricsCli(args: readonly string[]): Promise<number> {
-	const tasksRoot = args[0];
-	if (!tasksRoot) {
-		console.error("usage: bun run task-metrics <tasksRoot> [--board]");
-		return 1;
-	}
-
-	const report = args.includes("--board")
-		? await buildTaskBoard(tasksRoot)
-		: await analyzeTaskStoreMetrics(tasksRoot);
-	console.log(JSON.stringify(report, null, 2));
-	return 0;
-}
-
-if (import.meta.main) {
-	process.exitCode = await runTaskMetricsCli(process.argv.slice(2));
-}

package/src/metrics.ts

@@ -1,288 +0,0 @@
-import { readTaskStoreArtifacts } from "./task-artifacts";
-import type { TaskStoreArtifactRecord, TaskStoreDiagnostic } from "./task-artifacts";
-
-const LARGEST_LIST_LIMIT = 10;
-
-export interface TaskMetricCount {
-	readonly taskId: string;
-	readonly charCount: number;
-}
-
-export type TaskMetricsDiagnostic = TaskStoreDiagnostic;
-
-export interface TaskGroupingMetrics {
-	readonly byPhaseId: Readonly<Record<string, number>>;
-	readonly byIssueId: Readonly<Record<string, number>>;
-	readonly byRootCause: Readonly<Record<string, number>>;
-	readonly loopsPerIssueId: Readonly<Record<string, number>>;
-}
-
-export interface TaskStoreMetricsReport {
-	readonly schemaVersion: 1;
-	readonly tasksRoot: string;
-	readonly totalTaskRecords: number;
-	readonly statusCounts: Readonly<Record<string, number>>;
-	readonly preflight: {
-		readonly rejectedCount: number;
-		readonly failedChecksByName: Readonly<Record<string, number>>;
-		readonly unavailableChecksByName: Readonly<Record<string, number>>;
-	};
-	readonly characterSizes: {
-		readonly totalTaskTextChars: number;
-		readonly totalAssignmentChars: number;
-		readonly totalInstructionChars: number;
-		readonly totalResultSummaryChars: number;
-		readonly totalSerializedResultPayloadChars: number;
-	};
-	readonly largest: {
-		readonly taskPrompts: readonly TaskMetricCount[];
-		readonly results: readonly TaskMetricCount[];
-	};
-	readonly grouping: TaskGroupingMetrics;
-	readonly verification: {
-		readonly entryCount: number;
-		readonly commandCounts: Readonly<Record<string, number>>;
-		readonly statusCounts: Readonly<Record<string, number>>;
-	};
-	readonly diagnostics: readonly TaskMetricsDiagnostic[];
-}
-
-interface MutableTotals {
-	totalTaskRecords: number;
-	preflightRejectedCount: number;
-	totalTaskTextChars: number;
-	totalAssignmentChars: number;
-	totalInstructionChars: number;
-	totalResultSummaryChars: number;
-	totalSerializedResultPayloadChars: number;
-	verificationEntryCount: number;
-}
-
-export async function analyzeTaskStoreMetrics(tasksRoot: string): Promise<TaskStoreMetricsReport> {
-	const artifactRead = await readTaskStoreArtifacts(tasksRoot);
-	const diagnostics: TaskMetricsDiagnostic[] = [...artifactRead.diagnostics];
-	const taskPrompts: TaskMetricCount[] = [];
-	const results: TaskMetricCount[] = [];
-	const statusCounts: Record<string, number> = {};
-	const failedChecksByName: Record<string, number> = {};
-	const unavailableChecksByName: Record<string, number> = {};
-	const byPhaseId: Record<string, number> = {};
-	const byIssueId: Record<string, number> = {};
-	const byRootCause: Record<string, number> = {};
-	const commandCounts: Record<string, number> = {};
-	const verificationStatusCounts: Record<string, number> = {};
-	const totals: MutableTotals = {
-		totalTaskRecords: 0,
-		preflightRejectedCount: 0,
-		totalTaskTextChars: 0,
-		totalAssignmentChars: 0,
-		totalInstructionChars: 0,
-		totalResultSummaryChars: 0,
-		totalSerializedResultPayloadChars: 0,
-		verificationEntryCount: 0,
-	};
-	const analysis: TaskAnalysis = {
-		totals,
-		statusCounts,
-		failedChecksByName,
-		unavailableChecksByName,
-		byPhaseId,
-		byIssueId,
-		byRootCause,
-		commandCounts,
-		verificationStatusCounts,
-		taskPrompts,
-		results,
-	};
-
-	for (const record of artifactRead.records) {
-		analyzeTaskArtifact(record, analysis);
-	}
-
-	return buildReport(tasksRoot, totals, statusCounts, failedChecksByName, unavailableChecksByName, byPhaseId, byIssueId, byRootCause, commandCounts, verificationStatusCounts, taskPrompts, results, diagnostics);
-}
-
-interface TaskAnalysis {
-	readonly totals: MutableTotals;
-	readonly statusCounts: Record<string, number>;
-	readonly failedChecksByName: Record<string, number>;
-	readonly unavailableChecksByName: Record<string, number>;
-	readonly byPhaseId: Record<string, number>;
-	readonly byIssueId: Record<string, number>;
-	readonly byRootCause: Record<string, number>;
-	readonly commandCounts: Record<string, number>;
-	readonly verificationStatusCounts: Record<string, number>;
-	readonly taskPrompts: TaskMetricCount[];
-	readonly results: TaskMetricCount[];
-}
-
-function analyzeTaskArtifact(record: TaskStoreArtifactRecord, analysis: TaskAnalysis): void {
-	const task = record.task;
-	const taskId = typeof task.id === "string" && task.id.length > 0 ? task.id : record.taskDirectoryName;
-	analysis.totals.totalTaskRecords += 1;
-
-	const status = typeof task.status === "string" && task.status.length > 0 ? task.status : "unknown";
-	increment(analysis.statusCounts, status);
-
-	const taskText = typeof task.taskText === "string" ? task.taskText : "";
-	analysis.totals.totalTaskTextChars += taskText.length;
-	analysis.taskPrompts.push({ taskId, charCount: taskText.length });
-
-	analyzeMetadata(task.metadata, analysis);
-	analyzePreflight(task, status, analysis);
-	analyzeAssignment(record.assignment, analysis);
-	analyzeResult(record.result, taskId, analysis);
-}
-
-function analyzeMetadata(metadata: unknown, analysis: TaskAnalysis): void {
-	if (!isRecord(metadata)) {
-		return;
-	}
-	incrementStringField(analysis.byPhaseId, metadata.phaseId);
-	incrementStringField(analysis.byIssueId, metadata.issueId);
-	incrementStringField(analysis.byRootCause, metadata.rootCause);
-}
-
-function analyzePreflight(task: Record<string, unknown>, status: string, analysis: TaskAnalysis): void {
-	const preflight = isRecord(task.preflight) ? task.preflight : undefined;
-	const error = isRecord(task.error) ? task.error : undefined;
-	if (status === "rejected" && (error?.code === "preflight_failed" || preflight?.ok === false)) {
-		analysis.totals.preflightRejectedCount += 1;
-	}
-
-	if (!preflight || !Array.isArray(preflight.checks)) {
-		return;
-	}
-	for (const check of preflight.checks) {
-		if (!isRecord(check) || typeof check.name !== "string") {
-			continue;
-		}
-		if (check.status === "failed") {
-			increment(analysis.failedChecksByName, check.name);
-		} else if (check.status === "unavailable") {
-			increment(analysis.unavailableChecksByName, check.name);
-		}
-	}
-}
-
-function analyzeAssignment(assignment: unknown | undefined, analysis: TaskAnalysis): void {
-	if (assignment === undefined) {
-		return;
-	}
-	const serializedAssignment = JSON.stringify(assignment);
-	analysis.totals.totalAssignmentChars += typeof assignment === "string" ? assignment.length : serializedAssignment?.length ?? 0;
-	if (isRecord(assignment) && typeof assignment.instructions === "string") {
-		analysis.totals.totalInstructionChars += assignment.instructions.length;
-	}
-}
-
-function analyzeResult(
-	storedResult: Record<string, unknown> | undefined,
-	taskId: string,
-	analysis: TaskAnalysis,
-): void {
-	if (!storedResult) {
-		return;
-	}
-	const summaryChars = typeof storedResult.summary === "string" ? storedResult.summary.length : 0;
-	const payloadChars = "result" in storedResult ? (JSON.stringify(storedResult.result)?.length ?? 0) : 0;
-	analysis.totals.totalResultSummaryChars += summaryChars;
-	analysis.totals.totalSerializedResultPayloadChars += payloadChars;
-	analysis.results.push({ taskId, charCount: summaryChars + payloadChars });
-
-	if (!isRecord(storedResult.result) || !Array.isArray(storedResult.result.verification)) {
-		return;
-	}
-	for (const entry of storedResult.result.verification) {
-		analysis.totals.verificationEntryCount += 1;
-		if (!isRecord(entry)) {
-			continue;
-		}
-		if (typeof entry.command === "string" && entry.command.length > 0) {
-			increment(analysis.commandCounts, entry.command);
-		}
-		if (typeof entry.status === "string" && entry.status.length > 0) {
-			increment(analysis.verificationStatusCounts, entry.status);
-		}
-	}
-}
-
-function buildReport(
-	tasksRoot: string,
-	totals: MutableTotals,
-	statusCounts: Record<string, number>,
-	failedChecksByName: Record<string, number>,
-	unavailableChecksByName: Record<string, number>,
-	byPhaseId: Record<string, number>,
-	byIssueId: Record<string, number>,
-	byRootCause: Record<string, number>,
-	commandCounts: Record<string, number>,
-	verificationStatusCounts: Record<string, number>,
-	taskPrompts: TaskMetricCount[],
-	results: TaskMetricCount[],
-	diagnostics: TaskMetricsDiagnostic[],
-): TaskStoreMetricsReport {
-	const issueCounts = sortedCounts(byIssueId);
-	return {
-		schemaVersion: 1,
-		tasksRoot,
-		totalTaskRecords: totals.totalTaskRecords,
-		statusCounts: sortedCounts(statusCounts),
-		preflight: {
-			rejectedCount: totals.preflightRejectedCount,
-			failedChecksByName: sortedCounts(failedChecksByName),
-			unavailableChecksByName: sortedCounts(unavailableChecksByName),
-		},
-		characterSizes: {
-			totalTaskTextChars: totals.totalTaskTextChars,
-			totalAssignmentChars: totals.totalAssignmentChars,
-			totalInstructionChars: totals.totalInstructionChars,
-			totalResultSummaryChars: totals.totalResultSummaryChars,
-			totalSerializedResultPayloadChars: totals.totalSerializedResultPayloadChars,
-		},
-		largest: {
-			taskPrompts: largestFirst(taskPrompts),
-			results: largestFirst(results),
-		},
-		grouping: {
-			byPhaseId: sortedCounts(byPhaseId),
-			byIssueId: issueCounts,
-			byRootCause: sortedCounts(byRootCause),
-			loopsPerIssueId: { ...issueCounts },
-		},
-		verification: {
-			entryCount: totals.verificationEntryCount,
-			commandCounts: sortedCounts(commandCounts),
-			statusCounts: sortedCounts(verificationStatusCounts),
-		},
-		diagnostics,
-	};
-}
-
-function largestFirst(values: readonly TaskMetricCount[]): readonly TaskMetricCount[] {
-	return [...values]
-		.sort((left, right) => right.charCount - left.charCount || compareStrings(left.taskId, right.taskId))
-		.slice(0, LARGEST_LIST_LIMIT);
-}
-
-function sortedCounts(counts: Readonly<Record<string, number>>): Record<string, number> {
-	return Object.fromEntries(Object.entries(counts).sort(([left], [right]) => compareStrings(left, right)));
-}
-
-function compareStrings(left: string, right: string): number {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-
-function increment(counts: Record<string, number>, key: string): void {
-	counts[key] = (counts[key] ?? 0) + 1;
-}
-
-function incrementStringField(counts: Record<string, number>, value: unknown): void {
-	if (typeof value === "string" && value.length > 0) {
-		increment(counts, value);
-	}
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}

package/src/task-artifacts.ts

@@ -1,153 +0,0 @@
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-
-export interface TaskStoreDiagnostic {
-	readonly severity: "warning" | "error";
-	readonly code: string;
-	readonly path: string;
-	readonly message: string;
-}
-
-export interface TaskStoreArtifactRecord {
-	readonly taskDirectoryName: string;
-	readonly task: Record<string, unknown>;
-	readonly assignment: unknown | undefined;
-	readonly result: Record<string, unknown> | undefined;
-}
-
-export interface TaskStoreArtifactRead {
-	readonly records: readonly TaskStoreArtifactRecord[];
-	readonly diagnostics: readonly TaskStoreDiagnostic[];
-}
-
-type JsonReadResult =
-	| { readonly ok: true; readonly value: unknown }
-	| { readonly ok: false; readonly missing: boolean; readonly message: string };
-
-export async function readTaskStoreArtifacts(tasksRoot: string): Promise<TaskStoreArtifactRead> {
-	const diagnostics: TaskStoreDiagnostic[] = [];
-	const records: TaskStoreArtifactRecord[] = [];
-	let entries;
-	try {
-		entries = await readdir(tasksRoot, { withFileTypes: true });
-	} catch (error) {
-		diagnostics.push({
-			severity: "error",
-			code: "tasks_root_unreadable",
-			path: tasksRoot,
-			message: errorMessage(error),
-		});
-		return { records, diagnostics };
-	}
-
-	const directories = entries
-		.filter((entry) => entry.isDirectory())
-		.sort((left, right) => compareStrings(left.name, right.name));
-	for (const directory of directories) {
-		const taskDirectoryName = directory.name;
-		const taskRead = await readJson(join(tasksRoot, taskDirectoryName, "task.json"));
-		if (!taskRead.ok) {
-			diagnostics.push({
-				severity: taskRead.missing ? "warning" : "error",
-				code: taskRead.missing ? "missing_task_json" : "malformed_task_json",
-				path: join(taskDirectoryName, "task.json"),
-				message: taskRead.message,
-			});
-			continue;
-		}
-		if (!isRecord(taskRead.value)) {
-			diagnostics.push({
-				severity: "error",
-				code: "malformed_task_json",
-				path: join(taskDirectoryName, "task.json"),
-				message: "task.json must contain an object",
-			});
-			continue;
-		}
-
-		const assignment = await readAssignment(tasksRoot, taskDirectoryName, diagnostics);
-		const result = await readResult(tasksRoot, taskDirectoryName, diagnostics);
-		records.push({ taskDirectoryName, task: taskRead.value, assignment, result });
-	}
-
-	return { records, diagnostics };
-}
-
-async function readAssignment(
-	tasksRoot: string,
-	taskDirectoryName: string,
-	diagnostics: TaskStoreDiagnostic[],
-): Promise<unknown | undefined> {
-	const relativePath = join(taskDirectoryName, "assignment.json");
-	const assignmentRead = await readJson(join(tasksRoot, relativePath));
-	if (assignmentRead.ok) {
-		return assignmentRead.value;
-	}
-	if (!assignmentRead.missing) {
-		diagnostics.push({
-			severity: "error",
-			code: "malformed_assignment_json",
-			path: relativePath,
-			message: assignmentRead.message,
-		});
-	}
-	return undefined;
-}
-
-async function readResult(
-	tasksRoot: string,
-	taskDirectoryName: string,
-	diagnostics: TaskStoreDiagnostic[],
-): Promise<Record<string, unknown> | undefined> {
-	const relativePath = join(taskDirectoryName, "result.json");
-	const resultRead = await readJson(join(tasksRoot, relativePath));
-	if (!resultRead.ok) {
-		diagnostics.push({
-			severity: resultRead.missing ? "warning" : "error",
-			code: resultRead.missing ? "missing_result_json" : "malformed_result_json",
-			path: relativePath,
-			message: resultRead.message,
-		});
-		return undefined;
-	}
-	if (!isRecord(resultRead.value)) {
-		diagnostics.push({
-			severity: "error",
-			code: "malformed_result_json",
-			path: relativePath,
-			message: "result.json must contain an object",
-		});
-		return undefined;
-	}
-	return resultRead.value;
-}
-
-async function readJson(path: string): Promise<JsonReadResult> {
-	let text: string;
-	try {
-		text = await readFile(path, "utf8");
-	} catch (error) {
-		return { ok: false, missing: errorCode(error) === "ENOENT", message: errorMessage(error) };
-	}
-	try {
-		return { ok: true, value: JSON.parse(text) as unknown };
-	} catch (error) {
-		return { ok: false, missing: false, message: errorMessage(error) };
-	}
-}
-
-function compareStrings(left: string, right: string): number {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-function errorCode(error: unknown): string | undefined {
-	return isRecord(error) && typeof error.code === "string" ? error.code : undefined;
-}
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}