@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

package/src/goals/tools/goal-tool.ts

@@ -0,0 +1,237 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { formatNumber, prompt } from "@oh-my-pi/pi-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme, ThemeColor } from "../../modes/theme/theme";
+import goalDescription from "../../prompts/tools/goal.md" with { type: "text" };
+import { formatDuration } from "../../slash-commands/helpers/format";
+import type { ToolSession } from "../../tools";
+import { formatErrorMessage, TRUNCATE_LENGTHS } from "../../tools/render-utils";
+import { ToolError } from "../../tools/tool-errors";
+import { renderStatusLine, truncateToWidth } from "../../tui";
+import { completionBudgetReport, remainingTokens } from "../runtime";
+import type { Goal, GoalStatus, GoalToolDetails } from "../state";
+
+const goalSchema = Type.Object({
+	op: Type.Union([Type.Literal("create"), Type.Literal("get"), Type.Literal("complete")], {
+		description: "Goal operation.",
+	}),
+	objective: Type.Optional(Type.String({ description: "Goal objective. Required when op=create." })),
+	token_budget: Type.Optional(
+		Type.Integer({
+			description: "Optional positive token budget. Only honored when op=create.",
+		}),
+	),
+});
+
+export type GoalToolInput = Static<typeof goalSchema>;
+
+export interface GoalToolResponse {
+	goal: Goal | null;
+	remainingTokens: number | null;
+	completionBudgetReport: string | null;
+}
+
+export function buildGoalToolResponse(
+	goal: Goal | null | undefined,
+	options?: { includeCompletionReport?: boolean },
+): GoalToolResponse {
+	const resolvedGoal = goal ?? null;
+	return {
+		goal: resolvedGoal,
+		remainingTokens: remainingTokens(resolvedGoal),
+		completionBudgetReport:
+			options?.includeCompletionReport && resolvedGoal?.status === "complete"
+				? completionBudgetReport(resolvedGoal)
+				: null,
+	};
+}
+
+function validateCreateParams(params: GoalToolInput): { objective: string; tokenBudget?: number } {
+	const objective = params.objective?.trim();
+	if (!objective) {
+		throw new ToolError("objective is required when op=create");
+	}
+	const tokenBudget = params.token_budget;
+	if (tokenBudget !== undefined && (!Number.isInteger(tokenBudget) || tokenBudget <= 0)) {
+		throw new ToolError("token_budget must be a positive integer when provided");
+	}
+	return { objective, tokenBudget };
+}
+
+export class GoalTool implements AgentTool<typeof goalSchema, GoalToolDetails> {
+	readonly name = "goal";
+	readonly label = "Goal";
+	readonly description = prompt.render(goalDescription);
+	readonly parameters = goalSchema;
+	readonly strict = true;
+	readonly intent = "omit" as const;
+	readonly #session: ToolSession;
+
+	constructor(session: ToolSession) {
+		this.#session = session;
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: GoalToolInput,
+		_signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<GoalToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<GoalToolDetails>> {
+		const runtime = this.#session.getGoalRuntime?.();
+		if (!runtime) {
+			throw new ToolError("Goal mode is not active.");
+		}
+
+		let response: GoalToolResponse;
+		if (params.op === "create") {
+			const created = await runtime.createGoal(validateCreateParams(params));
+			response = buildGoalToolResponse(created.goal);
+		} else if (params.op === "get") {
+			const state = this.#session.getGoalModeState?.();
+			response = buildGoalToolResponse(state?.enabled ? state.goal : null);
+		} else {
+			const completed = await runtime.completeGoalFromTool();
+			response = buildGoalToolResponse(completed, { includeCompletionReport: true });
+		}
+		let text: string;
+		if (response.goal) {
+			text = `Goal: ${response.goal.objective}\nStatus: ${response.goal.status}\nTokens: ${response.goal.tokensUsed} used`;
+			if (response.goal.tokenBudget !== undefined) {
+				text += ` / ${response.goal.tokenBudget} budget`;
+			}
+			if (response.remainingTokens !== null) {
+				text += `\nRemaining tokens: ${response.remainingTokens}`;
+			}
+			if (response.completionBudgetReport) {
+				text += `\n\n${response.completionBudgetReport}`;
+			}
+		} else {
+			text = "No active goal.";
+		}
+		return {
+			content: [{ type: "text", text }],
+			details: {
+				op: params.op,
+				goal: response.goal,
+				remainingTokens: response.remainingTokens,
+				completionBudgetReport: response.completionBudgetReport,
+			},
+		};
+	}
+}
+
+function describeOp(op: string | undefined): string {
+	switch (op) {
+		case "create":
+			return "set";
+		case "complete":
+			return "complete";
+		case "get":
+			return "check";
+		default:
+			return op ?? "?";
+	}
+}
+
+function goalBadgeColor(status: GoalStatus): ThemeColor {
+	switch (status) {
+		case "complete":
+			return "success";
+		case "budget-limited":
+			return "warning";
+		case "paused":
+		case "dropped":
+			return "muted";
+		default:
+			return "accent";
+	}
+}
+
+interface GoalRenderArgs {
+	op?: GoalToolInput["op"];
+	objective?: string;
+	token_budget?: number;
+}
+
+export const goalToolRenderer = {
+	renderCall(args: GoalRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const description = describeOp(args.op);
+		const meta: string[] = [];
+		const trimmedObjective = args.objective?.trim();
+		if (args.op === "create" && trimmedObjective) {
+			const objective = truncateToWidth(trimmedObjective, TRUNCATE_LENGTHS.TITLE);
+			meta.push(uiTheme.italic(uiTheme.fg("muted", `"${objective}"`)));
+		}
+		if (args.op === "create" && args.token_budget !== undefined) {
+			meta.push(`budget ${formatNumber(args.token_budget)}`);
+		}
+		const text = renderStatusLine({ icon: "pending", title: "Goal", description, meta }, uiTheme);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: GoalToolDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		uiTheme: Theme,
+		args?: GoalRenderArgs,
+	): Component {
+		const fallbackText = result.content?.find(c => c.type === "text")?.text ?? "";
+		const details = result.details;
+		const op = details?.op ?? args?.op;
+		const description = describeOp(op);
+
+		if (result.isError) {
+			const header = renderStatusLine({ icon: "error", title: "Goal", description }, uiTheme);
+			const body = formatErrorMessage(fallbackText || "Goal tool failed", uiTheme);
+			return new Text([header, body].join("\n"), 0, 0);
+		}
+
+		const goal = details?.goal ?? null;
+		if (!goal) {
+			const header = renderStatusLine({ icon: "warning", title: "Goal", description }, uiTheme);
+			const body = uiTheme.fg("muted", "No active goal.");
+			return new Text([header, body].join("\n"), 0, 0);
+		}
+
+		const lines: string[] = [];
+		lines.push(
+			renderStatusLine(
+				{
+					icon: "success",
+					title: "Goal",
+					description,
+					badge: { label: goal.status, color: goalBadgeColor(goal.status) },
+				},
+				uiTheme,
+			),
+		);
+
+		const objectiveText = truncateToWidth(goal.objective.trim(), TRUNCATE_LENGTHS.LONG);
+		lines.push(`  ${uiTheme.italic(uiTheme.fg("muted", `"${objectiveText}"`))}`);
+
+		const used = formatNumber(goal.tokensUsed);
+		const tokensLine =
+			goal.tokenBudget !== undefined
+				? `${used} / ${formatNumber(goal.tokenBudget)} tokens (${formatNumber(Math.max(0, goal.tokenBudget - goal.tokensUsed))} left)`
+				: `${used} tokens`;
+		lines.push(`  ${uiTheme.fg("dim", tokensLine)}`);
+
+		if (goal.timeUsedSeconds > 0) {
+			lines.push(`  ${uiTheme.fg("dim", `${formatDuration(goal.timeUsedSeconds * 1000)} elapsed`)}`);
+		}
+
+		const report = details?.completionBudgetReport;
+		if (report) {
+			lines.push("");
+			lines.push(uiTheme.italic(uiTheme.fg("muted", report)));
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+
+	mergeCallAndResult: true,
+};

package/src/hashline/anchors.ts

@@ -63,9 +63,9 @@ export class HashlineMismatchError extends Error {
 	}
 
 	private static rejectionHeader(mismatches: HashMismatch[]): string[] {
-		const noun = mismatches.length > 1 ? "lines have" : "line has";
+		const noun = mismatches.length > 1 ? "anchors do" : "anchor does";
 		return [
-			`Edit rejected: ${mismatches.length} ${noun} changed since the last read (marked *).`,
+			`Edit rejected: ${mismatches.length} ${noun} not match the current file (marked *).`,
 			"The edit was NOT applied, please use the updated file content shown below, and issue another edit tool-call.",
 		];
 	}

package/src/hashline/input.ts

@@ -108,7 +108,8 @@ export function splitHashlineInputs(input: string, options: SplitHashlineOptions
 
 	const flush = () => {
 		if (currentPath.length === 0) return;
-		sections.push({ path: currentPath, diff: currentLines.join("\n") });
+		const hasOps = currentLines.some(rawLine => stripTrailingCarriageReturn(rawLine).trim().length > 0);
+		if (hasOps) sections.push({ path: currentPath, diff: currentLines.join("\n") });
 		currentLines = [];
 	};
 

package/src/hashline/parser.ts

@@ -86,9 +86,33 @@ function collectPayload(
 	let index = startIndex;
 	while (index < lines.length) {
 		const line = stripTrailingCarriageReturn(lines[index]);
-		if (!line.startsWith(HL_EDIT_SEP)) break;
-		payload.push(line.slice(1));
-		index++;
+		if (line.startsWith(HL_EDIT_SEP)) {
+			payload.push(line.slice(1));
+			index++;
+			continue;
+		}
+		// Silently recover from a missing payload prefix on an otherwise blank
+		// line: if more payload follows (possibly past further blanks), treat
+		// each intervening blank as an empty `${HL_EDIT_SEP}` payload line.
+		// Additionally, when the op explicitly requires payload (`+`/`<`) and
+		// we have not collected any yet, accept the blank(s) themselves as the
+		// empty payload — common typo of forgetting the `${HL_EDIT_SEP}` prefix
+		// when inserting a blank line.
+		if (line.length === 0) {
+			let lookahead = index + 1;
+			while (lookahead < lines.length && stripTrailingCarriageReturn(lines[lookahead]).length === 0) {
+				lookahead++;
+			}
+			const followedByPayload =
+				lookahead < lines.length && stripTrailingCarriageReturn(lines[lookahead]).startsWith(HL_EDIT_SEP);
+			const acceptBareBlank = requirePayload && payload.length === 0;
+			if (followedByPayload || acceptBareBlank) {
+				for (let j = index; j < lookahead; j++) payload.push("");
+				index = lookahead;
+				continue;
+			}
+		}
+		break;
 	}
 	if (payload.length === 0 && requirePayload) {
 		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);

package/src/hindsight/mental-models.ts

@@ -379,4 +379,4 @@ export const MENTAL_MODEL_FIRST_TURN_DEADLINE_MS = 1500;
 export const MENTAL_MODEL_REFRESH_INTERVAL_MS = 5 * 60 * 1000;
 
 /** Need-only export of the raw seed list for tests. */
-export const __builtinSeedsForTest: ReadonlyArray<Readonly<RawSeed>> = BUILTIN_SEEDS;
+export const builtinSeedsForTest: ReadonlyArray<Readonly<RawSeed>> = BUILTIN_SEEDS;

package/src/internal-urls/agent-protocol.ts

@@ -14,29 +14,10 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
-import { AgentRegistry } from "../registry/agent-registry";
 import { applyQuery, pathToQuery } from "./json-query";
+import { artifactsDirsFromRegistry } from "./registry-helpers";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-/**
- * Snapshot of artifacts dirs for every registered session, deduped.
- *
- * Prefers `sessionManager.getArtifactsDir()` because subagents adopt the
- * parent's manager and report the parent's dir there; dedup then collapses
- * the whole agent tree to one entry. Falls back to the raw session file
- * when no live session reference is attached.
- */
-function artifactsDirsFromRegistry(): string[] {
-	const dirs: string[] = [];
-	for (const ref of AgentRegistry.global().list()) {
-		const dir =
-			ref.session?.sessionManager.getArtifactsDir() ?? (ref.sessionFile ? ref.sessionFile.slice(0, -6) : null);
-		if (!dir) continue;
-		if (!dirs.includes(dir)) dirs.push(dir);
-	}
-	return dirs;
-}
-
 /**
  * Handler for agent:// URLs.
  *

package/src/internal-urls/artifact-protocol.ts

@@ -12,27 +12,9 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { isEnoent } from "@oh-my-pi/pi-utils";
-import { AgentRegistry } from "../registry/agent-registry";
+import { artifactsDirsFromRegistry } from "./registry-helpers";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
-/**
- * Snapshot of artifacts dirs across all registered sessions, deduped.
- *
- * Subagents adopt their parent's `ArtifactManager`, so their
- * `sessionManager.getArtifactsDir()` returns the parent's dir; dedup
- * collapses parent + N subagents to a single entry.
- */
-function artifactsDirsFromRegistry(): string[] {
-	const dirs: string[] = [];
-	for (const ref of AgentRegistry.global().list()) {
-		const dir =
-			ref.session?.sessionManager.getArtifactsDir() ?? (ref.sessionFile ? ref.sessionFile.slice(0, -6) : null);
-		if (!dir) continue;
-		if (!dirs.includes(dir)) dirs.push(dir);
-	}
-	return dirs;
-}
-
 export class ArtifactProtocolHandler implements ProtocolHandler {
 	readonly scheme = "artifact";
 	readonly immutable = true;