@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/cli/grep-cli.ts

@@ -4,7 +4,7 @@
  * Handles `omp grep` subcommand for testing grep tool on Windows.
  */
 import * as path from "node:path";
-import { grep } from "@oh-my-pi/pi-natives";
+import { GrepOutputMode, grep } from "@oh-my-pi/pi-natives";
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 
@@ -14,7 +14,7 @@ export interface GrepCommandArgs {
 	glob?: string;
 	limit: number;
 	context: number;
-	mode: "content" | "filesWithMatches" | "count";
+	mode: GrepOutputMode;
 	gitignore: boolean;
 }
 
@@ -32,7 +32,7 @@ export function parseGrepArgs(args: string[]): GrepCommandArgs | undefined {
 		path: ".",
 		limit: 20,
 		context: 2,
-		mode: "content",
+		mode: GrepOutputMode.Content,
 		gitignore: true,
 	};
 
@@ -47,9 +47,9 @@ export function parseGrepArgs(args: string[]): GrepCommandArgs | undefined {
 		} else if (arg === "--context" || arg === "-C") {
 			result.context = parseInt(args[++i], 10);
 		} else if (arg === "--files" || arg === "-f") {
-			result.mode = "filesWithMatches";
+			result.mode = GrepOutputMode.FilesWithMatches;
 		} else if (arg === "--count" || arg === "-c") {
-			result.mode = "count";
+			result.mode = GrepOutputMode.Count;
 		} else if (arg === "--no-gitignore") {
 			result.gitignore = false;
 		} else if (!arg.startsWith("-")) {
@@ -89,7 +89,7 @@ export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
 			glob: cmd.glob,
 			mode: cmd.mode,
 			maxCount: cmd.limit,
-			context: cmd.mode === "content" ? cmd.context : undefined,
+			context: cmd.mode === GrepOutputMode.Content ? cmd.context : undefined,
 			hidden: true,
 			gitignore: cmd.gitignore,
 		});
@@ -105,7 +105,7 @@ export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
 		for (const match of result.matches) {
 			const displayPath = match.path.replace(/\\/g, "/");
 
-			if (cmd.mode === "content") {
+			if (cmd.mode === GrepOutputMode.Content) {
 				if (match.contextBefore) {
 					for (const ctx of match.contextBefore) {
 						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
@@ -118,7 +118,7 @@ export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
 					}
 				}
 				console.log("");
-			} else if (cmd.mode === "count") {
+			} else if (cmd.mode === GrepOutputMode.Count) {
 				console.log(`${chalk.cyan(displayPath)}: ${match.matchCount ?? 0} matches`);
 			} else {
 				console.log(chalk.cyan(displayPath));

package/src/cli/grievances-cli.ts

@@ -0,0 +1,78 @@
+/**
+ * CLI handler for `omp grievances` — view reported tool issues from auto-QA.
+ */
+import { Database } from "bun:sqlite";
+import chalk from "chalk";
+import { getAutoQaDbPath } from "../tools/report-tool-issue";
+
+interface GrievanceRow {
+	id: number;
+	model: string;
+	version: string;
+	tool: string;
+	report: string;
+}
+
+export interface ListGrievancesOptions {
+	limit: number;
+	tool?: string;
+	json: boolean;
+}
+
+function openDb(): Database | null {
+	try {
+		const db = new Database(getAutoQaDbPath(), { readonly: true });
+		return db;
+	} catch {
+		return null;
+	}
+}
+
+export async function listGrievances(options: ListGrievancesOptions): Promise<void> {
+	const db = openDb();
+	if (!db) {
+		if (options.json) {
+			console.log("[]");
+		} else {
+			console.log(
+				chalk.dim("No grievances database found. Enable auto-QA with PI_AUTO_QA=1 or the dev.autoqa setting."),
+			);
+		}
+		return;
+	}
+
+	try {
+		let rows: GrievanceRow[];
+		if (options.tool) {
+			rows = db
+				.prepare("SELECT id, model, version, tool, report FROM grievances WHERE tool = ? ORDER BY id DESC LIMIT ?")
+				.all(options.tool, options.limit) as GrievanceRow[];
+		} else {
+			rows = db
+				.prepare("SELECT id, model, version, tool, report FROM grievances ORDER BY id DESC LIMIT ?")
+				.all(options.limit) as GrievanceRow[];
+		}
+
+		if (options.json) {
+			console.log(JSON.stringify(rows, null, 2));
+			return;
+		}
+
+		if (rows.length === 0) {
+			console.log(chalk.dim("No grievances recorded yet."));
+			return;
+		}
+
+		for (const row of rows) {
+			console.log(
+				`${chalk.dim(`#${row.id}`)} ${chalk.cyan(row.tool)} ${chalk.dim(`(${row.model} v${row.version})`)}`,
+			);
+			console.log(`  ${row.report}`);
+			console.log();
+		}
+
+		console.log(chalk.dim(`Showing ${rows.length} most recent${options.tool ? ` for ${options.tool}` : ""}`));
+	} finally {
+		db.close();
+	}
+}

package/src/cli/read-cli.ts

@@ -0,0 +1,67 @@
+/**
+ * Read CLI command handler.
+ *
+ * Handles `omp read` subcommand — emits chunk-mode read output for files,
+ * and delegates URL reads through the read tool pipeline.
+ */
+import * as path from "node:path";
+import chalk from "chalk";
+import { Settings } from "../config/settings";
+import { formatChunkedRead, resolveAnchorStyle } from "../edit/modes/chunk";
+import { getLanguageFromPath } from "../modes/theme/theme";
+import type { ToolSession } from "../tools";
+import { parseReadUrlTarget } from "../tools/fetch";
+import { ReadTool } from "../tools/read";
+
+export interface ReadCommandArgs {
+	path: string;
+	sel?: string;
+}
+
+function createCliReadSession(cwd: string, settings: Settings): ToolSession {
+	return {
+		cwd,
+		hasUI: false,
+		hasEditTool: true,
+		getSessionFile: () => null,
+		getSessionSpawns: () => null,
+		settings,
+	};
+}
+
+export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
+	const cwd = process.cwd();
+	const parsedUrlTarget = parseReadUrlTarget(cmd.path, cmd.sel);
+	if (parsedUrlTarget) {
+		const settings = await Settings.init({ cwd });
+		const tool = new ReadTool(createCliReadSession(cwd, settings));
+		const result = await tool.execute("cli-read", { path: cmd.path, sel: cmd.sel });
+		const text = result.content.find((content): content is { type: "text"; text: string } => content.type === "text");
+		console.log(text?.text ?? "");
+		return;
+	}
+
+	const filePath = path.resolve(cmd.path);
+	const file = Bun.file(filePath);
+	if (!(await file.exists())) {
+		console.error(chalk.red(`Error: File not found: ${cmd.path}`));
+		process.exit(1);
+	}
+
+	const readPath = cmd.sel ? `${filePath}:${cmd.sel}` : filePath;
+	const language = getLanguageFromPath(filePath);
+
+	try {
+		const result = await formatChunkedRead({
+			filePath,
+			readPath,
+			cwd,
+			language,
+			anchorStyle: resolveAnchorStyle(),
+		});
+		console.log(result.text);
+	} catch (err) {
+		console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+		process.exit(1);
+	}
+}

package/src/cli/setup-cli.ts

@@ -4,7 +4,7 @@
  * Handles `omp setup <component>` to install dependencies for optional features.
  */
 import * as path from "node:path";
-import { APP_NAME, getPythonEnvDir } from "@oh-my-pi/pi-utils";
+import { $which, APP_NAME, getPythonEnvDir } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import chalk from "chalk";
 import { theme } from "../modes/theme/theme";
@@ -90,12 +90,12 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 		managedEnvPath: MANAGED_PYTHON_ENV,
 	};
 
-	const systemPythonPath = Bun.which("python") ?? Bun.which("python3");
+	const systemPythonPath = $which("python") ?? $which("python3");
 	const managedPath = managedPythonPath();
 	const hasManagedEnv = await Bun.file(managedPath).exists();
 
-	result.uvPath = Bun.which("uv") ?? undefined;
-	result.pipPath = Bun.which("pip3") ?? Bun.which("pip") ?? undefined;
+	result.uvPath = $which("uv") ?? undefined;
+	result.pipPath = $which("pip3") ?? $which("pip") ?? undefined;
 
 	const candidates = [systemPythonPath, hasManagedEnv ? managedPath : undefined].filter(
 		(candidate): candidate is string => !!candidate,

package/src/cli/update-cli.ts

@@ -7,7 +7,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { pipeline } from "node:stream/promises";
-import { APP_NAME, isEnoent, VERSION } from "@oh-my-pi/pi-utils";
+import { $which, APP_NAME, isEnoent, VERSION } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import chalk from "chalk";
 import { theme } from "../modes/theme/theme";
@@ -36,7 +36,7 @@ export function parseUpdateArgs(args: string[]): { force: boolean; check: boolea
 }
 
 async function getBunGlobalBinDir(): Promise<string | undefined> {
-	if (!Bun.which("bun")) return undefined;
+	if (!$which("bun")) return undefined;
 	try {
 		const result = await $`bun pm bin -g`.quiet().nothrow();
 		if (result.exitCode !== 0) return undefined;
@@ -167,7 +167,7 @@ function getBinaryName(): string {
  * Resolve the path that `omp` maps to in the user's PATH.
  */
 function resolveOmpPath(): string | undefined {
-	return Bun.which(APP_NAME) ?? undefined;
+	return $which(APP_NAME) ?? undefined;
 }
 
 /**

package/src/cli.ts

@@ -48,6 +48,8 @@ const commands: CommandEntry[] = [
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "grep", load: () => import("./commands/grep").then(m => m.default) },
+	{ name: "grievances", load: () => import("./commands/grievances").then(m => m.default) },
+	{ name: "read", load: () => import("./commands/read").then(m => m.default) },
 	{ name: "jupyter", load: () => import("./commands/jupyter").then(m => m.default) },
 	{ name: "plugin", load: () => import("./commands/plugin").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },

package/src/commands/grep.ts

@@ -1,6 +1,7 @@
 /**
  * Test grep tool.
  */
+import { GrepOutputMode } from "@oh-my-pi/pi-natives";
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { type GrepCommandArgs, runGrepCommand } from "../cli/grep-cli";
 import { initTheme } from "../modes/theme/theme";
@@ -25,7 +26,11 @@ export default class Grep extends Command {
 	async run(): Promise<void> {
 		const { args, flags } = await this.parse(Grep);
 
-		const mode: GrepCommandArgs["mode"] = flags.count ? "count" : flags.files ? "filesWithMatches" : "content";
+		const mode: GrepCommandArgs["mode"] = flags.count
+			? GrepOutputMode.Count
+			: flags.files
+				? GrepOutputMode.FilesWithMatches
+				: GrepOutputMode.Content;
 
 		const cmd: GrepCommandArgs = {
 			pattern: args.pattern ?? "",

package/src/commands/grievances.ts

@@ -0,0 +1,20 @@
+/**
+ * View recently reported tool issues from automated QA.
+ */
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { listGrievances } from "../cli/grievances-cli";
+
+export default class Grievances extends Command {
+	static description = "View reported tool issues (auto-QA grievances)";
+
+	static flags = {
+		limit: Flags.integer({ char: "n", description: "Number of recent issues to show", default: 20 }),
+		tool: Flags.string({ char: "t", description: "Filter by tool name" }),
+		json: Flags.boolean({ char: "j", description: "Output as JSON", default: false }),
+	};
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Grievances);
+		await listGrievances({ limit: flags.limit, tool: flags.tool, json: flags.json });
+	}
+}

package/src/commands/read.ts

@@ -0,0 +1,33 @@
+/**
+ * Chunk-mode read tool.
+ */
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { type ReadCommandArgs, runReadCommand } from "../cli/read-cli";
+import { initTheme } from "../modes/theme/theme";
+
+export default class Read extends Command {
+	static description = "Read a file as a chunk tree";
+
+	static args = {
+		path: Args.string({ description: "File path to read", required: true }),
+	};
+
+	static flags = {
+		sel: Flags.string({
+			char: "s",
+			description: "Chunk selector or line range (e.g. class_Foo.fn_bar, L10-L20)",
+		}),
+	};
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Read);
+
+		const cmd: ReadCommandArgs = {
+			path: args.path ?? "",
+			sel: flags.sel,
+		};
+
+		await initTheme();
+		await runReadCommand(cmd);
+	}
+}

package/src/commit/agentic/agent.ts

@@ -1,11 +1,10 @@
 import { INTENT_FIELD, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import { Markdown } from "@oh-my-pi/pi-tui";
+import { prompt } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
-import type { ControlledGit } from "../../commit/git";
 import typesDescriptionPrompt from "../../commit/prompts/types-description.md" with { type: "text" };
 import type { ModelRegistry } from "../../config/model-registry";
-import { renderPromptTemplate } from "../../config/prompt-templates";
 import type { Settings } from "../../config/settings";
 import { getMarkdownTheme } from "../../modes/theme/theme";
 import { createAgentSession } from "../../sdk";
@@ -18,7 +17,6 @@ import { createCommitTools } from "./tools";
 
 export interface CommitAgentInput {
 	cwd: string;
-	git: ControlledGit;
 	model: Model<Api>;
 	thinkingLevel?: ThinkingLevel;
 	settings: Settings;
@@ -38,15 +36,14 @@ export interface ExistingChangelogEntries {
 }
 
 export async function runCommitAgentSession(input: CommitAgentInput): Promise<CommitAgentState> {
-	const typesDescription = renderPromptTemplate(typesDescriptionPrompt);
-	const systemPrompt = renderPromptTemplate(agentSystemPrompt, {
+	const typesDescription = prompt.render(typesDescriptionPrompt);
+	const systemPrompt = prompt.render(agentSystemPrompt, {
 		types_description: typesDescription,
 	});
 	const state: CommitAgentState = { diffText: input.diffText };
 	const spawns = "quick_task";
 	const tools = createCommitTools({
 		cwd: input.cwd,
-		git: input.git,
 		authStorage: input.authStorage,
 		modelRegistry: input.modelRegistry,
 		settings: input.settings,
@@ -152,7 +149,7 @@ export async function runCommitAgentSession(input: CommitAgentInput): Promise<Co
 	});
 
 	try {
-		const prompt = renderPromptTemplate(agentUserPrompt, {
+		const agentUserMessage = prompt.render(agentUserPrompt, {
 			user_context: input.userContext,
 			changelog_targets: input.changelogTargets.length > 0 ? input.changelogTargets.join("\n") : undefined,
 			existing_changelog_entries: input.existingChangelogEntries,
@@ -161,7 +158,7 @@ export async function runCommitAgentSession(input: CommitAgentInput): Promise<Co
 		let retryCount = 0;
 		const needsChangelog = input.requireChangelog && input.changelogTargets.length > 0;
 
-		await session.prompt(prompt, {
+		await session.prompt(agentUserMessage, {
 			attribution: "agent",
 			expandPromptTemplates: false,
 		});

package/src/commit/agentic/index.ts

@@ -1,17 +1,16 @@
 import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
-import { $env, getProjectDir, isEnoent } from "@oh-my-pi/pi-utils";
+import { $env, getProjectDir, isEnoent, prompt } from "@oh-my-pi/pi-utils";
 import { applyChangelogProposals } from "../../commit/changelog";
 import { detectChangelogBoundaries } from "../../commit/changelog/detect";
 import { parseUnreleasedSection } from "../../commit/changelog/parse";
-import { ControlledGit } from "../../commit/git";
 import { formatCommitMessage } from "../../commit/message";
 import { resolvePrimaryModel, resolveSmolModel } from "../../commit/model-selection";
 import type { CommitCommandArgs, ConventionalAnalysis } from "../../commit/types";
 import { ModelRegistry } from "../../config/model-registry";
-import { renderPromptTemplate } from "../../config/prompt-templates";
 import { Settings } from "../../config/settings";
 import { discoverAuthStorage, discoverContextFiles } from "../../sdk";
+import * as git from "../../utils/git";
 import { type ExistingChangelogEntries, runCommitAgentSession } from "./agent";
 import { generateFallbackProposal } from "./fallback";
 import splitConfirmPrompt from "./prompts/split-confirm.md" with { type: "text" };
@@ -20,25 +19,24 @@ import { computeDependencyOrder } from "./topo-sort";
 import { detectTrivialChange } from "./trivial";
 
 interface CommitExecutionContext {
-	git: ControlledGit;
+	cwd: string;
 	dryRun: boolean;
 	push: boolean;
 }
 
 export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const cwd = getProjectDir();
-	const git = new ControlledGit(cwd);
 	const [settings, authStorage] = await Promise.all([Settings.init({ cwd }), discoverAuthStorage()]);
 
 	process.stdout.write("● Resolving model...\n");
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
 	const stagedFilesPromise = (async () => {
-		let stagedFiles = await git.getStagedFiles();
+		let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		if (stagedFiles.length === 0) {
 			process.stdout.write("No staged changes detected, staging all changes...\n");
-			await git.stageAll();
-			stagedFiles = await git.getStagedFiles();
+			await git.stage.files(cwd);
+			stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		}
 		return stagedFiles;
 	})();
@@ -66,8 +64,8 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	const [changelogBoundaries, contextFiles, numstat, diff] = await Promise.all([
 		args.noChangelog ? [] : detectChangelogBoundaries(cwd, stagedFiles),
 		discoverContextFiles(cwd),
-		git.getNumstat(true),
-		git.getDiff(true),
+		git.diff.numstat(cwd, { cached: true }),
+		git.diff(cwd, { cached: true }),
 	]);
 	const changelogTargets = changelogBoundaries.map(boundary => boundary.changelogPath);
 	if (!args.noChangelog) {
@@ -93,7 +91,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	if (forceFallback) {
 		process.stdout.write("● Forcing fallback commit generation...\n");
 		const fallbackProposal = generateFallbackProposal(numstat);
-		await runSingleCommit(fallbackProposal, { git, dryRun: args.dryRun, push: args.push });
+		await runSingleCommit(fallbackProposal, { cwd, dryRun: args.dryRun, push: args.push });
 		return;
 	}
 
@@ -110,7 +108,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 			summary: trivialChange.summary,
 			warnings: [],
 		};
-		await runSingleCommit(trivialProposal, { git, dryRun: args.dryRun, push: args.push });
+		await runSingleCommit(trivialProposal, { cwd, dryRun: args.dryRun, push: args.push });
 		return;
 	}
 
@@ -129,7 +127,6 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	try {
 		commitState = await runCommitAgentSession({
 			cwd,
-			git,
 			model: agentModel,
 			thinkingLevel: agentThinkingLevel,
 			settings,
@@ -169,7 +166,6 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 		}
 		process.stdout.write("● Applying changelog entries...\n");
 		const updated = await applyChangelogProposals({
-			git,
 			cwd,
 			proposals: commitState.changelogProposal.entries,
 			dryRun: args.dryRun,
@@ -188,13 +184,13 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	}
 
 	if (commitState.proposal) {
-		await runSingleCommit(commitState.proposal, { git, dryRun: args.dryRun, push: args.push });
+		await runSingleCommit(commitState.proposal, { cwd, dryRun: args.dryRun, push: args.push });
 		return;
 	}
 
 	if (commitState.splitProposal) {
 		await runSplitCommit(commitState.splitProposal, {
-			git,
+			cwd,
 			dryRun: args.dryRun,
 			push: args.push,
 			additionalFiles: updatedChangelogFiles,
@@ -215,10 +211,10 @@ async function runSingleCommit(proposal: CommitProposal, ctx: CommitExecutionCon
 		process.stdout.write(`${commitMessage}\n`);
 		return;
 	}
-	await ctx.git.commit(commitMessage);
+	await git.commit(ctx.cwd, commitMessage);
 	process.stdout.write("Commit created.\n");
 	if (ctx.push) {
-		await ctx.git.push();
+		await git.push(ctx.cwd);
 		process.stdout.write("Pushed to remote.\n");
 	}
 }
@@ -233,7 +229,7 @@ async function runSplitCommit(
 	if (ctx.additionalFiles && ctx.additionalFiles.length > 0) {
 		appendFilesToLastCommit(plan, ctx.additionalFiles);
 	}
-	const stagedFiles = await ctx.git.getStagedFiles();
+	const stagedFiles = await git.diff.changedFiles(ctx.cwd, { cached: true });
 	const plannedFiles = new Set(plan.commits.flatMap(commit => commit.changes.map(change => change.path)));
 	const missingFiles = stagedFiles.filter(file => !plannedFiles.has(file));
 	if (missingFiles.length > 0) {
@@ -270,10 +266,10 @@ async function runSplitCommit(
 		throw new Error(order.error);
 	}
 
-	await ctx.git.resetStaging();
+	await git.stage.reset(ctx.cwd);
 	for (const commitIndex of order) {
 		const commit = plan.commits[commitIndex];
-		await ctx.git.stageHunks(commit.changes);
+		await git.stage.hunks(ctx.cwd, commit.changes);
 		const analysis: ConventionalAnalysis = {
 			type: commit.type,
 			scope: commit.scope,
@@ -281,12 +277,12 @@ async function runSplitCommit(
 			issueRefs: commit.issueRefs,
 		};
 		const message = formatCommitMessage(analysis, commit.summary);
-		await ctx.git.commit(message);
-		await ctx.git.resetStaging();
+		await git.commit(ctx.cwd, message);
+		await git.stage.reset(ctx.cwd);
 	}
 	process.stdout.write("Split commits created.\n");
 	if (ctx.push) {
-		await ctx.git.push();
+		await git.push(ctx.cwd);
 		process.stdout.write("Pushed to remote.\n");
 	}
 }
@@ -308,8 +304,8 @@ async function confirmSplitCommitPlan(plan: SplitCommitPlan): Promise<boolean> {
 	}
 	const rl = createInterface({ input: process.stdin, output: process.stdout });
 	try {
-		const prompt = renderPromptTemplate(splitConfirmPrompt, { count: plan.commits.length });
-		const answer = await rl.question(prompt);
+		const splitConfirmQuestion = prompt.render(splitConfirmPrompt, { count: plan.commits.length });
+		const answer = await rl.question(splitConfirmQuestion);
 		return ["y", "yes"].includes(answer.trim().toLowerCase());
 	} finally {
 		rl.close();

package/src/commit/agentic/tools/analyze-file.ts

@@ -1,9 +1,9 @@
+import { prompt } from "@oh-my-pi/pi-utils";
 import { Type } from "@sinclair/typebox";
 import analyzeFilePrompt from "../../../commit/agentic/prompts/analyze-file.md" with { type: "text" };
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { NumstatEntry } from "../../../commit/types";
 import type { ModelRegistry } from "../../../config/model-registry";
-import { renderPromptTemplate } from "../../../config/prompt-templates";
 import type { Settings } from "../../../config/settings";
 import type { CustomTool, CustomToolContext } from "../../../extensibility/custom-tools/types";
 import type { AuthStorage } from "../../../session/auth-storage";
@@ -66,7 +66,7 @@ export function createAnalyzeFileTool(options: {
 			const numstat = options.state.overview?.numstat ?? [];
 			const tasks = params.files.map((file, index) => {
 				const relatedFiles = formatRelatedFiles(params.files, file, numstat);
-				const prompt = renderPromptTemplate(analyzeFilePrompt, {
+				const assignment = prompt.render(analyzeFilePrompt, {
 					file,
 					goal: params.goal,
 					related_files: relatedFiles,
@@ -74,7 +74,7 @@ export function createAnalyzeFileTool(options: {
 				return {
 					id: `AnalyzeFile${index + 1}`,
 					description: `Analyze ${file}`,
-					assignment: prompt,
+					assignment,
 				};
 			});
 			const taskParams: TaskParams = {

package/src/commit/agentic/tools/git-file-diff.ts

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import type { CommitAgentState } from "../../../commit/agentic/state";
-import type { ControlledGit } from "../../../commit/git";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 
 const TARGET_TOKENS = 30000;
 const CHARS_PER_TOKEN = 4;
@@ -136,10 +136,7 @@ const gitFileDiffSchema = Type.Object({
 	staged: Type.Optional(Type.Boolean({ description: "Use staged changes (default: true)" })),
 });
 
-export function createGitFileDiffTool(
-	git: ControlledGit,
-	state: CommitAgentState,
-): CustomTool<typeof gitFileDiffSchema> {
+export function createGitFileDiffTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitFileDiffSchema> {
 	return {
 		name: "git_file_diff",
 		label: "Git File Diff",
@@ -167,7 +164,7 @@ export function createGitFileDiffTool(
 
 			if (uncachedFiles.length > 0) {
 				for (const file of uncachedFiles) {
-					const diff = await git.getDiffForFiles([file], staged);
+					const diff = await git.diff(cwd, { cached: staged, files: [file] });
 					if (diff) {
 						diffs.set(file, diff);
 						state.diffCache.set(cacheKey(file), diff);

package/src/commit/agentic/tools/git-hunk.ts

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
-import type { ControlledGit } from "../../../commit/git";
 import type { DiffHunk, FileHunks } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
+import * as git from "../../../utils/git";
 
 const gitHunkSchema = Type.Object({
 	file: Type.String({ description: "File path" }),
@@ -15,7 +15,7 @@ function selectHunks(fileHunks: FileHunks, requested?: number[]): DiffHunk[] {
 	return fileHunks.hunks.filter(hunk => wanted.has(hunk.index + 1));
 }
 
-export function createGitHunkTool(git: ControlledGit): CustomTool<typeof gitHunkSchema> {
+export function createGitHunkTool(cwd: string): CustomTool<typeof gitHunkSchema> {
 	return {
 		name: "git_hunk",
 		label: "Git Hunk",
@@ -23,7 +23,7 @@ export function createGitHunkTool(git: ControlledGit): CustomTool<typeof gitHunk
 		parameters: gitHunkSchema,
 		async execute(_toolCallId, params) {
 			const staged = params.staged ?? true;
-			const hunks = await git.getHunks([params.file], staged);
+			const hunks = await git.diff.hunks(cwd, [params.file], { cached: staged });
 			const fileHunks = hunks.find(entry => entry.filename === params.file) ?? {
 				filename: params.file,
 				isBinary: false,