@oh-my-pi/pi-coding-agent 15.2.2 → 15.2.4

package/src/tools/gh.ts

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 
-import { getWorktreesDir, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
+import { getWorktreeDir, hashPath, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { Settings } from "../config/settings";
 import githubDescription from "../prompts/tools/github.md" with { type: "text" };
@@ -859,18 +859,8 @@ function sanitizeRemoteName(value: string): string {
 	return sanitized.length > 0 ? `fork-${sanitized}` : "fork";
 }
 
-/**
- * Encode an absolute repository path into a single filesystem-safe segment.
- * Mirrors the legacy session-dir encoding used elsewhere in the project: drop
- * the leading separator, then collapse `/`, `\\`, and `:` to `-`. The result
- * is not strictly injective for pathological inputs (e.g. `/a/b` vs `/a-b`)
- * but matches the rest of the codebase and stays human-readable.
- */
-function encodeRepoPathForFilesystem(repoPath: string): string {
-	const resolved = path.resolve(repoPath);
-	const encoded = resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-");
-	return encoded || "root";
-}
+/** Maximum disambiguation suffixes we try before giving up on a worktree path. */
+const WORKTREE_PATH_MAX_SUFFIX = 100;
 
 function toLocalBranchRef(value: string): string {
 	return `refs/heads/${value}`;
@@ -912,25 +902,38 @@ async function requireCurrentGitHead(cwd: string, signal?: AbortSignal): Promise
 	return headSha;
 }
 
-async function ensureGitWorktreePathAvailable(
-	worktreePath: string,
+/**
+ * Resolve a worktree path that is free of conflicts.
+ *
+ * Given a `basePath`, return either `basePath` itself or `${basePath}-2`,
+ * `${basePath}-3`, … up to {@link WORKTREE_PATH_MAX_SUFFIX} — whichever is the
+ * first variant that is **not** registered with git as another worktree and
+ * **not** present on disk. The numeric tail salvages two rare cases that
+ * would otherwise abort a checkout: stale leftover dirs from an interrupted
+ * `git worktree add`, and the (vanishingly unlikely) `hashPath` collision
+ * between two repos that happen to produce the same 7-hex digest.
+ */
+async function resolveAvailableWorktreePath(
+	basePath: string,
 	existingWorktrees: git.GitWorktreeEntry[],
-): Promise<void> {
-	const normalizedTarget = path.resolve(worktreePath);
-	const conflictingWorktree = existingWorktrees.find(entry => path.resolve(entry.path) === normalizedTarget);
-	if (conflictingWorktree) {
-		throw new ToolError(`worktree path is already registered: ${conflictingWorktree.path}`);
-	}
-
-	try {
-		await fs.stat(normalizedTarget);
-		throw new ToolError(`worktree path already exists: ${normalizedTarget}`);
-	} catch (error) {
-		if (isEnoent(error)) {
-			return;
+): Promise<string> {
+	const registered = new Set(existingWorktrees.map(entry => path.resolve(entry.path)));
+	for (let attempt = 0; attempt < WORKTREE_PATH_MAX_SUFFIX; attempt += 1) {
+		const candidate = attempt === 0 ? basePath : `${basePath}-${attempt + 1}`;
+		const normalized = path.resolve(candidate);
+		if (registered.has(normalized)) continue;
+		try {
+			await fs.stat(normalized);
+		} catch (error) {
+			if (isEnoent(error)) {
+				return candidate;
+			}
+			throw error;
 		}
-		throw error;
 	}
+	throw new ToolError(
+		`could not find an unused worktree path under ${basePath} (tried ${WORKTREE_PATH_MAX_SUFFIX} suffixes)`,
+	);
 }
 
 function selectPrCloneUrl(originUrl: string | undefined, repo: Pick<GhRepoViewData, "url" | "sshUrl">): string {
@@ -2939,7 +2942,7 @@ async function checkoutPullRequest(
 	const repoRoot = await requireGitRepoRoot(session.cwd, signal);
 	const primaryRepoRoot = await requirePrimaryGitRepoRoot(repoRoot, signal);
 	const localBranch = `pr-${prNumber}`;
-	const worktreePath = path.join(getWorktreesDir(), encodeRepoPathForFilesystem(primaryRepoRoot), localBranch);
+	const worktreePath = getWorktreeDir(`${prNumber}-${hashPath(primaryRepoRoot)}`);
 
 	// Every git mutation against `repoRoot` from here on must run under the
 	// per-repo lock. Worktrees of the same primary repo share `.git/config`,
@@ -3003,9 +3006,9 @@ async function checkoutPullRequest(
 				signal,
 			);
 
-			const finalWorktreePath = existingWorktree?.path ?? worktreePath;
+			let finalWorktreePath = existingWorktree?.path ?? worktreePath;
 			if (!existingWorktree) {
-				await ensureGitWorktreePathAvailable(finalWorktreePath, existingWorktrees);
+				finalWorktreePath = await resolveAvailableWorktreePath(worktreePath, existingWorktrees);
 				await fs.mkdir(path.dirname(finalWorktreePath), { recursive: true });
 				await git.worktree.add(repoRoot, finalWorktreePath, localBranch, { signal });
 			}

package/src/utils/commit-message-generator.ts

@@ -15,6 +15,8 @@ import { toReasoningEffort } from "../thinking";
 
 const COMMIT_SYSTEM_PROMPT = prompt.render(commitSystemPrompt);
 const MAX_DIFF_CHARS = 4000;
+const COMMIT_MAX_TOKENS = 60;
+const REASONING_SAFE_MAX_TOKENS = 1024;
 
 /** File patterns that should be excluded from commit message generation diffs. */
 const NOISE_SUFFIXES = [".lock", ".lockb", "-lock.json", "-lock.yaml"];
@@ -99,13 +101,16 @@ export async function generateCommitMessage(
 		if (!apiKey) continue;
 
 		try {
+			const maxTokens = candidate.model.reasoning
+				? Math.max(COMMIT_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
+				: COMMIT_MAX_TOKENS;
 			const response = await completeSimple(
 				candidate.model,
 				{
 					systemPrompt: [COMMIT_SYSTEM_PROMPT],
 					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
 				},
-				{ apiKey, maxTokens: 60, reasoning: toReasoningEffort(candidate.thinkingLevel) },
+				{ apiKey, maxTokens, reasoning: toReasoningEffort(candidate.thinkingLevel) },
 			);
 
 			if (response.stopReason === "error") {

package/src/utils/git.ts

@@ -1157,6 +1157,10 @@ export const worktree = {
 	async list(cwd: string, signal?: AbortSignal): Promise<GitWorktreeEntry[]> {
 		return parseWorktreeList(await runText(cwd, ["worktree", "list", "--porcelain"], { readOnly: true, signal }));
 	},
+
+	async prune(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runEffect(cwd, ["worktree", "prune"], { signal });
+	},
 };
 
 // ════════════════════════════════════════════════════════════════════════════

package/src/utils/title-generator.ts

@@ -3,7 +3,7 @@
  */
 import * as path from "node:path";
 
-import { type Api, completeSimple, type Model } from "@oh-my-pi/pi-ai";
+import { type Api, type AssistantMessage, completeSimple, type Model, type Tool } from "@oh-my-pi/pi-ai";
 import { logger, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { resolveRoleSelection } from "../config/model-resolver";
@@ -16,6 +16,25 @@ const DEFAULT_TERMINAL_TITLE = "π";
 const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
 
 const MAX_INPUT_CHARS = 2000;
+const TITLE_MAX_TOKENS = 30;
+const REASONING_SAFE_MAX_TOKENS = 1024;
+const SET_TITLE_TOOL_NAME = "set_title";
+
+const setTitleTool: Tool = {
+	name: SET_TITLE_TOOL_NAME,
+	description: "Set the generated session title.",
+	parameters: {
+		type: "object",
+		properties: {
+			title: {
+				type: "string",
+				description: "A concise 3-6 word title for the session.",
+			},
+		},
+		required: ["title"],
+		additionalProperties: false,
+	},
+};
 
 function getTitleModel(registry: ModelRegistry, settings: Settings, currentModel?: Model<Api>): Model<Api> | undefined {
 	const availableModels = registry.getAvailable();
@@ -76,14 +95,16 @@ ${truncatedMessage}
 	// account_uuid rather than the snapshot-at-call-site value.
 	const metadata = metadataResolver?.(model.provider);
 
-	// Title generation is a 3-6 word task; force reasoning off so reasoning models
-	// don't burn the entire output budget on internal thinking and return an empty
-	// string. With reasoning disabled, 30 tokens of output is plenty.
+	// Title generation is a 3-6 word task, but some reasoning backends ignore
+	// disableReasoning. Keep the normal cheap budget for non-reasoning models
+	// while reserving enough output room for reasoning models to still emit
+	// the forced tool call after any unavoidable thinking tokens.
+	const maxTokens = model.reasoning ? Math.max(TITLE_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : TITLE_MAX_TOKENS;
 	const request = {
 		model: `${model.provider}/${model.id}`,
 		systemPrompt: TITLE_SYSTEM_PROMPT,
 		userMessage,
-		maxTokens: 30,
+		maxTokens,
 	};
 	logger.debug("title-generator: request", request);
 
@@ -93,11 +114,13 @@ ${truncatedMessage}
 			{
 				systemPrompt: [request.systemPrompt],
 				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
+				tools: [setTitleTool],
 			},
 			{
 				apiKey,
-				maxTokens: 30,
+				maxTokens: request.maxTokens,
 				disableReasoning: true,
+				toolChoice: { type: "tool", name: SET_TITLE_TOOL_NAME },
 				metadata,
 			},
 		);
@@ -111,13 +134,7 @@ ${truncatedMessage}
 			return null;
 		}
 
-		let title = "";
-		for (const content of response.content) {
-			if (content.type === "text") {
-				title += content.text;
-			}
-		}
-		title = title.trim();
+		const title = extractGeneratedTitle(response.content);
 
 		logger.debug("title-generator: response", {
 			model: request.model,
@@ -140,6 +157,21 @@ ${truncatedMessage}
 	}
 }
 
+function extractGeneratedTitle(contentBlocks: AssistantMessage["content"]): string {
+	let textTitle = "";
+	for (const content of contentBlocks) {
+		if (content.type === "toolCall" && content.name === SET_TITLE_TOOL_NAME) {
+			const args = content.arguments as Record<string, unknown>;
+			const title = args.title;
+			return typeof title === "string" ? title.trim() : "";
+		}
+		if (content.type === "text") {
+			textTitle += content.text;
+		}
+	}
+	return textTitle.trim();
+}
+
 /**
  * Remove control characters so model-generated titles cannot inject terminal escapes.
  */