diffing 0.16.1 → 0.17.0

package/dist/{cli-agent-Dk0yRtrA.mjs → cli-agent-qNwkSjxK.mjs}

@@ -25,6 +25,13 @@ const EXIT_AWAIT_TIMEOUT = 2;
 const EXIT_NO_SERVER = 3;
 const EXIT_NOT_FOUND = 4;
 const EXIT_USAGE = 5;
+function validateInspectSelectors(resource, file, path) {
+	const hasFile = file != null && file !== "";
+	const hasPath = path != null && path !== "";
+	if ((resource === "hunks" || resource === "slice") && hasFile && hasPath) return `diffing inspect ${resource}: --path and --file are mutually exclusive`;
+	if ((resource === "hunks" || resource === "slice") && !hasFile && !hasPath) return `diffing inspect ${resource}: --file or --path is required`;
+	return null;
+}
 let activeCapability;
 let activeAuthToken;
 /** Resolve the running server's base URL from the lockfile, or exit cleanly. */
@@ -880,6 +887,8 @@ async function inspect(args) {
 				cursor: { type: "string" },
 				limit: { type: "string" },
 				file: { type: "string" },
+				path: { type: "string" },
+				exclude: { type: "string" },
 				generation: { type: "string" },
 				start: { type: "string" },
 				row: { type: "string" },
@@ -906,12 +915,13 @@ async function inspect(args) {
 		console.error(`Usage: diffing inspect <summary|files|hunks|slice|search> [options]
 
 Read bounded data from a running session (web, TUI, or gh-pr) without transferring the full patch.
-  summary
-  files   [--cursor N] [--limit N]
-  hunks   --file N [--cursor N] [--limit N] [--generation N]
-  slice   --file N [--start N] [--max-lines N] [--max-bytes N] [--generation N]
-  search  <text>|--query <text> [--file N] [--row N] [--limit N] [--max-bytes N] [--generation N]
+  summary [--exclude lockfiles]
+  files   [--path GLOB] [--cursor N] [--limit N]
+  hunks   (--file N | --path GLOB) [--cursor N] [--limit N] [--generation N]
+  slice   (--file N | --path GLOB) [--start N] [--max-lines N] [--max-bytes N] [--generation N]
+  search  <text>|--query <text> [--path GLOB] [--file N] [--row N] [--limit N] [--max-bytes N] [--generation N]
 
+Filtered files nextCursor is an index into the filtered list, not a global file index.
 Add --pretty for indented JSON. Compact JSON is the token-efficient default.`);
 		return parsed.values.help ? EXIT_OK : EXIT_USAGE;
 	}
@@ -945,8 +955,13 @@ Add --pretty for indented JSON. Compact JSON is the token-efficient default.`);
 		}
 		params.set(parameter, value);
 	}
-	if ((resource === "hunks" || resource === "slice") && !params.has("file")) {
-		console.error(`diffing inspect ${resource}: --file is required`);
+	const path = parsed.values.path;
+	if (typeof path === "string") params.set("path", path);
+	const exclude = parsed.values.exclude;
+	if (typeof exclude === "string") params.set("exclude", exclude);
+	const selectorError = validateInspectSelectors(resource, typeof parsed.values.file === "string" ? parsed.values.file : void 0, typeof path === "string" ? path : void 0);
+	if (selectorError) {
+		console.error(selectorError);
 		return EXIT_USAGE;
 	}
 	if (resource === "search") {

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as buildTuiGitDiffArgs, c as printHelp, n as runTerminalDiff, o as intoShowMode, r as validateEnvironment, s as parseDiffOptions, t as startServer } from "./server-Ct9QuV1l.mjs";
+import { a as buildTuiGitDiffArgs, c as printHelp, n as runTerminalDiff, o as intoShowMode, r as validateEnvironment, s as parseDiffOptions, t as startServer } from "./server-CEbp7K-k.mjs";
 import { h as getRepoRoot, r as getBranchName } from "./git-BGj31GX-.mjs";
 import { i as loadSettings } from "./settings-DkPDB_hS.mjs";
 import { _ as generateSessionToken, b as isWildcardBindHost, c as removeServerLockIfOwned, p as writeServerLock, r as diffScopeKey, t as acquireServerStartupLease, u as resolveActiveServerLock } from "./server-lock-CdaUNZyX.mjs";
@@ -561,11 +561,11 @@ See docs/cli.md §5 (MCP) for the full tool table.`);
 			console.error("diffing mcp: --repo must be an absolute path");
 			process.exit(5);
 		}
-		const { startMcpServer } = await import("./mcp-BgrRjzn3.mjs");
+		const { startMcpServer } = await import("./mcp-DhynPewa.mjs");
 		await startMcpServer({ repoPath });
 		await new Promise(() => {});
 	}
-	const { runSubcommand } = await import("./cli-agent-Dk0yRtrA.mjs");
+	const { runSubcommand } = await import("./cli-agent-qNwkSjxK.mjs");
 	const code = await runSubcommand(args[0], args.slice(1));
 	process.exit(code);
 }

package/dist/{mcp-BgrRjzn3.mjs → mcp-DhynPewa.mjs}

@@ -1,4 +1,4 @@
-import { i as buildGitDiffArgs, s as parseDiffOptions, t as startServer } from "./server-Ct9QuV1l.mjs";
+import { i as buildGitDiffArgs, s as parseDiffOptions, t as startServer } from "./server-CEbp7K-k.mjs";
 import { t as formatComments } from "./comment-format-B85NHZnG.mjs";
 import { n as formatPlanReview } from "./plan-format-BwJh5JSE.mjs";
 import { _ as generateSessionToken, c as removeServerLockIfOwned, i as isLockAlive, p as writeServerLock, r as diffScopeKey, s as removeServerLock, t as acquireServerStartupLease, u as resolveActiveServerLock, x as SESSION_TOKEN_HEADER, y as isLoopbackHost } from "./server-lock-CdaUNZyX.mjs";
@@ -618,54 +618,67 @@ function createMcpServer(options) {
 	});
 	server.registerTool("diff_summary", {
 		title: "Summarize the active diff (bounded)",
-		description: "Return bounded totals and change-kind counts without transferring the patch. Works for web, TUI, and GitHub PR sessions. Prefer this over get_diff.",
-		inputSchema: {},
+		description: "Return bounded totals, top-level directory buckets, and change-kind counts without transferring the patch. Optional exclude=[\"lockfiles\"] drops lock/generated basenames from counts only. Works for web, TUI, and GitHub PR sessions. Prefer this over get_diff.",
+		inputSchema: { exclude: z.array(z.enum(["lockfiles"])).optional() },
 		outputSchema: { result: z.unknown() },
 		annotations: READ_ONLY
-	}, async () => {
-		const result = await requestSessionJson(requireInspectSession(), "/api/diff/summary");
+	}, async ({ exclude } = {}) => {
+		const session = requireInspectSession();
+		const query = new URLSearchParams();
+		if (exclude?.length) query.set("exclude", exclude.join(","));
+		const result = await requestSessionJson(session, `/api/diff/summary${query.size ? `?${query}` : ""}`);
 		return textResult(JSON.stringify(result), { result });
 	});
 	server.registerTool("diff_files", {
 		title: "Page changed files (bounded)",
-		description: "Return a bounded page of changed-file metadata with an opaque numeric continuation cursor. Works for web, TUI, and GitHub PR sessions.",
+		description: "Return a bounded page of changed-file metadata. Optional path is a git pathspec-ish glob (src/lib/**, **/foo.ts). cursor/nextCursor index the filtered list; each row still has the global file index. Works for web, TUI, and GitHub PR sessions.",
 		inputSchema: {
 			cursor: z.number().int().nonnegative().optional(),
-			limit: z.number().int().positive().max(1e3).optional()
+			limit: z.number().int().positive().max(1e3).optional(),
+			path: z.string().min(1).optional()
 		},
 		outputSchema: { result: z.unknown() },
 		annotations: READ_ONLY
-	}, async ({ cursor = 0, limit = 100 }) => {
-		const result = await requestSessionJson(requireInspectSession(), `/api/diff/files?cursor=${cursor}&limit=${limit}`);
+	}, async ({ cursor = 0, limit = 100, path }) => {
+		const session = requireInspectSession();
+		const query = new URLSearchParams({
+			cursor: String(cursor),
+			limit: String(limit)
+		});
+		if (path) query.set("path", path);
+		const result = await requestSessionJson(session, `/api/diff/files?${query}`);
 		return textResult(JSON.stringify(result), { result });
 	});
 	server.registerTool("diff_hunks", {
 		title: "Page hunk metadata (bounded)",
-		description: "Return bounded hunk metadata for one file index. Pass generation from diff_summary to reject stale navigation. Works for web, TUI, and GitHub PR sessions.",
+		description: "Return bounded hunk metadata for one file. Pass path (glob resolving to exactly one file) or file (global index), not both. Pass generation from diff_summary to reject stale navigation. Works for web, TUI, and GitHub PR sessions.",
 		inputSchema: {
-			file: z.number().int().nonnegative(),
+			file: z.number().int().nonnegative().optional(),
+			path: z.string().min(1).optional(),
 			generation: z.number().int().nonnegative().optional(),
 			cursor: z.number().int().nonnegative().optional(),
 			limit: z.number().int().positive().max(1e3).optional()
 		},
 		outputSchema: { result: z.unknown() },
 		annotations: READ_ONLY
-	}, async ({ file, generation, cursor = 0, limit = 100 }) => {
+	}, async ({ file, path, generation, cursor = 0, limit = 100 }) => {
 		const session = requireInspectSession();
 		const query = new URLSearchParams({
-			file: String(file),
 			cursor: String(cursor),
 			limit: String(limit)
 		});
+		if (file !== void 0) query.set("file", String(file));
+		if (path) query.set("path", path);
 		if (generation !== void 0) query.set("generation", String(generation));
 		const result = await requestSessionJson(session, `/api/diff/hunks?${query}`);
 		return textResult(JSON.stringify(result), { result });
 	});
 	server.registerTool("diff_slice", {
 		title: "Read a bounded diff slice",
-		description: "Read exact logical rows for one file with strict line and byte budgets; use nextRow to continue. Works for web, TUI, and GitHub PR sessions. Prefer this over get_diff.",
+		description: "Read exact logical rows for one file with strict line and byte budgets; use nextRow to continue. Pass path (glob resolving to exactly one file) or file (global index), not both. Works for web, TUI, and GitHub PR sessions. Prefer this over get_diff.",
 		inputSchema: {
-			file: z.number().int().nonnegative(),
+			file: z.number().int().nonnegative().optional(),
+			path: z.string().min(1).optional(),
 			start: z.number().int().nonnegative().optional(),
 			generation: z.number().int().nonnegative().optional(),
 			maxLines: z.number().int().positive().max(1e3).optional(),
@@ -673,23 +686,25 @@ function createMcpServer(options) {
 		},
 		outputSchema: { result: z.unknown() },
 		annotations: READ_ONLY
-	}, async ({ file, start = 0, generation, maxLines = 120, maxBytes = 256 * 1024 }) => {
+	}, async ({ file, path, start = 0, generation, maxLines = 120, maxBytes = 256 * 1024 }) => {
 		const session = requireInspectSession();
 		const query = new URLSearchParams({
-			file: String(file),
 			start: String(start),
 			maxLines: String(maxLines),
 			maxBytes: String(maxBytes)
 		});
+		if (file !== void 0) query.set("file", String(file));
+		if (path) query.set("path", path);
 		if (generation !== void 0) query.set("generation", String(generation));
 		const result = await requestSessionJson(session, `/api/diff/slice?${query}`);
 		return textResult(JSON.stringify(result), { result });
 	});
 	server.registerTool("diff_search", {
 		title: "Search the active diff (bounded)",
-		description: "Search changed paths and content with bounded hits/bytes and generation-safe continuation coordinates. Works for web, TUI, and GitHub PR sessions.",
+		description: "Search changed paths and content with bounded hits/bytes and generation-safe continuation coordinates. Optional path glob limits hits to matching files (in addition to file+row continuation). Works for web, TUI, and GitHub PR sessions.",
 		inputSchema: {
 			query: z.string().min(1),
+			path: z.string().min(1).optional(),
 			generation: z.number().int().nonnegative().optional(),
 			file: z.number().int().nonnegative().optional(),
 			row: z.number().int().nonnegative().optional(),
@@ -698,7 +713,7 @@ function createMcpServer(options) {
 		},
 		outputSchema: { result: z.unknown() },
 		annotations: READ_ONLY
-	}, async ({ query, generation, file = 0, row = 0, limit = 100, maxBytes = 256 * 1024 }) => {
+	}, async ({ query, path, generation, file = 0, row = 0, limit = 100, maxBytes = 256 * 1024 }) => {
 		const session = requireInspectSession();
 		const params = new URLSearchParams({
 			q: query,
@@ -707,6 +722,7 @@ function createMcpServer(options) {
 			limit: String(limit),
 			maxBytes: String(maxBytes)
 		});
+		if (path) params.set("path", path);
 		if (generation !== void 0) params.set("generation", String(generation));
 		const result = await requestSessionJson(session, `/api/diff/search?${params}`);
 		return textResult(JSON.stringify(result), { result });

package/dist/{server-Ct9QuV1l.mjs → server-CEbp7K-k.mjs}

@@ -2201,6 +2201,113 @@ var FilePrSessionStore = class {
 		} catch {}
 	}
 };
+const PATH_MATCH_CAP = 20;
+function compilePathspecGlob(pattern) {
+	const source = pattern.trim();
+	if (!source) return {
+		error: "invalid path glob: empty pattern",
+		status: 400,
+		path: pattern
+	};
+	try {
+		return {
+			source,
+			test: compileGlobTester(source)
+		};
+	} catch (error) {
+		return {
+			error: error instanceof Error ? error.message : "invalid path glob",
+			status: 400,
+			path: pattern
+		};
+	}
+}
+function fileMatchesPath(matcher, oldPath, newPath) {
+	if (newPath && matcher.test(newPath)) return true;
+	if (oldPath && matcher.test(oldPath)) return true;
+	return false;
+}
+function parseExcludeList(raw) {
+	if (raw == null) return [];
+	const values = (Array.isArray(raw) ? raw : raw.split(",")).map((value) => value.trim()).filter(Boolean);
+	for (const value of values) if (value !== "lockfiles") return {
+		error: `unknown exclude: ${value}`,
+		status: 400
+	};
+	return [...new Set(values)];
+}
+function isLockfileNoise(path) {
+	const base = path.split("/").pop() ?? path;
+	if (base === "package-lock.json" || base === "pnpm-lock.yaml") return true;
+	if (base.endsWith(".lock")) return true;
+	if (base.endsWith(".min.js")) return true;
+	return false;
+}
+function displayPath(oldPath, newPath) {
+	return newPath ?? oldPath ?? "";
+}
+function capPathMatches(matches) {
+	return matches.slice(0, PATH_MATCH_CAP);
+}
+function compileGlobTester(pattern) {
+	const parts = (pattern.includes("/") ? pattern : `**/${pattern}`).split("/");
+	for (const part of parts) {
+		if (part !== "**" && part.includes("**")) throw new Error(`invalid path glob: ${pattern}`);
+		validateGlobSegment(part, pattern);
+	}
+	return (path) => matchParts(parts, path.split("/"));
+}
+function matchParts(pat, path) {
+	if (pat.length === 0) return path.length === 0;
+	if (pat[0] === "**") return matchParts(pat.slice(1), path) || path.length > 0 && matchParts(pat, path.slice(1));
+	if (path.length === 0) return false;
+	return globSegment(pat[0], path[0]) && matchParts(pat.slice(1), path.slice(1));
+}
+function validateGlobSegment(segment, pattern) {
+	for (let i = 0; i < segment.length; i++) {
+		if (segment[i] === "[") {
+			const close = segment.indexOf("]", i + 1);
+			if (close < 0 || close === i + 1) throw new Error(`invalid path glob: ${pattern}`);
+			i = close;
+			continue;
+		}
+		if (segment[i] === "\\") {
+			if (segment[i + 1] == null) throw new Error(`invalid path glob: ${pattern}`);
+			i++;
+		}
+	}
+}
+function globSegment(pattern, value) {
+	return globChars([...pattern], [...value]);
+}
+function globChars(pattern, value) {
+	if (pattern.length === 0) return value.length === 0;
+	const [head, ...rest] = pattern;
+	if (head === "*") return globChars(rest, value) || value.length > 0 && globChars(pattern, value.slice(1));
+	if (head === "?") return value.length > 0 && globChars(rest, value.slice(1));
+	if (head === "[") {
+		const close = rest.indexOf("]");
+		if (close < 0 || value.length === 0) return false;
+		const classBody = rest.slice(0, close);
+		const negated = classBody[0] === "!" || classBody[0] === "^";
+		if (classMatches(negated ? classBody.slice(1) : classBody, value[0]) === negated) return false;
+		return globChars(rest.slice(close + 1), value.slice(1));
+	}
+	if (head === "\\") return rest.length > 0 && value.length > 0 && rest[0] === value[0] && globChars(rest.slice(1), value.slice(1));
+	return value.length > 0 && head === value[0] && globChars(rest, value.slice(1));
+}
+function classMatches(body, value) {
+	for (let i = 0; i < body.length;) {
+		if (i + 2 < body.length && body[i + 1] === "-") {
+			if (body[i] <= value && value <= body[i + 2]) return true;
+			i += 3;
+			continue;
+		}
+		if (body[i] === value) return true;
+		i++;
+	}
+	return false;
+}
 //#endregion
 //#region src/lib/agent-diff-index.ts
 /**
@@ -2429,33 +2536,140 @@ function buildAgentDiffIndex(patch, generation = nextGeneration++) {
 		patchBytes
 	};
 }
-function indexSummary(index) {
+const DIRECTORY_CAP = 20;
+function indexSummary(index, excludeRaw) {
+	const exclude = parseExcludeList(excludeRaw);
+	if ("error" in exclude) return exclude;
+	const counted = exclude.includes("lockfiles") ? index.files.filter((file) => !isLockfileNoise(displayPath(file.oldPath, file.newPath))) : index.files;
 	const changes = {};
-	for (const file of index.files) changes[file.kind] = (changes[file.kind] ?? 0) + 1;
-	return {
+	let hunks = 0;
+	let rows = 0;
+	let additions = 0;
+	let deletions = 0;
+	for (const file of counted) {
+		changes[file.kind] = (changes[file.kind] ?? 0) + 1;
+		hunks += file.hunks.length;
+		rows += file.rowCount;
+		additions += file.additions;
+		deletions += file.deletions;
+	}
+	const summary = {
 		generation: index.generation,
 		complete: index.complete,
-		files: index.files.length,
-		hunks: index.totalHunks,
-		rows: index.totalRows,
-		additions: index.additions,
-		deletions: index.deletions,
+		files: counted.length,
+		hunks,
+		rows,
+		additions,
+		deletions,
 		patchBytes: index.patchBytes,
 		changes,
+		directories: summarizeDirectories(counted),
 		next: [
 			"diff_files",
 			"diff_search",
 			"diff_slice"
 		]
 	};
+	if (exclude.length > 0) summary.exclude = exclude;
+	return summary;
+}
+function summarizeDirectories(files) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const path = displayPath(file.oldPath, file.newPath);
+		const slash = path.indexOf("/");
+		const dir = slash < 0 ? "." : path.slice(0, slash);
+		const bucket = buckets.get(dir) ?? {
+			path: dir,
+			files: 0,
+			hunks: 0,
+			additions: 0,
+			deletions: 0
+		};
+		bucket.files += 1;
+		bucket.hunks += file.hunks.length;
+		bucket.additions += file.additions;
+		bucket.deletions += file.deletions;
+		buckets.set(dir, bucket);
+	}
+	const ranked = [...buckets.values()].sort((a, b) => {
+		if (b.files !== a.files) return b.files - a.files;
+		return b.additions + b.deletions - (a.additions + a.deletions);
+	});
+	if (ranked.length <= DIRECTORY_CAP) return ranked;
+	const head = ranked.slice(0, DIRECTORY_CAP);
+	const rest = ranked.slice(DIRECTORY_CAP);
+	const other = {
+		path: "+other",
+		files: 0,
+		hunks: 0,
+		additions: 0,
+		deletions: 0
+	};
+	for (const bucket of rest) {
+		other.files += bucket.files;
+		other.hunks += bucket.hunks;
+		other.additions += bucket.additions;
+		other.deletions += bucket.deletions;
+	}
+	head.push(other);
+	return head;
+}
+function scopedFiles(index, path) {
+	if (path == null || path === "") return { entries: index.files.map((file, i) => ({
+		index: i,
+		file
+	})) };
+	const matcher = compilePathspecGlob(path);
+	if ("error" in matcher) return matcher;
+	return {
+		matcher,
+		entries: index.files.flatMap((file, i) => fileMatchesPath(matcher, file.oldPath, file.newPath) ? [{
+			index: i,
+			file
+		}] : [])
+	};
+}
+function resolveInspectFile(index, file, path) {
+	const hasFile = file != null;
+	const hasPath = path != null && path !== "";
+	if (hasFile && hasPath) return {
+		error: "path and file are mutually exclusive",
+		status: 400,
+		path
+	};
+	if (!hasFile && !hasPath) return {
+		error: "file or path is required",
+		status: 400
+	};
+	if (hasFile) return { fileIndex: file };
+	const scoped = scopedFiles(index, path);
+	if ("error" in scoped) return scoped;
+	if (scoped.entries.length === 0) return {
+		error: "path matched no files",
+		status: 404,
+		path
+	};
+	if (scoped.entries.length > 1) return {
+		error: "path matched multiple files; narrow the glob or pass file",
+		status: 409,
+		path,
+		matches: capPathMatches(scoped.entries.map(({ index, file }) => ({
+			index,
+			path: displayPath(file.oldPath, file.newPath)
+		})))
+	};
+	return { fileIndex: scoped.entries[0].index };
 }
-function indexFiles(index, cursor = 0, limit = 100) {
+function indexFiles(index, cursor = 0, limit = 100, path) {
+	const scoped = scopedFiles(index, path);
+	if ("error" in scoped) return scoped;
 	const safeLimit = clamp(limit, 1, MAX_PAGE_LINES);
 	const start = Math.max(0, cursor);
-	const end = Math.min(index.files.length, start + safeLimit);
-	const files = index.files.slice(start, end).map((file, offset) => ({
-		index: start + offset,
-		path: file.newPath ?? file.oldPath ?? "",
+	const end = Math.min(scoped.entries.length, start + safeLimit);
+	const files = scoped.entries.slice(start, end).map(({ index, file }) => ({
+		index,
+		path: displayPath(file.oldPath, file.newPath),
 		oldPath: file.oldPath,
 		newPath: file.newPath,
 		kind: file.kind,
@@ -2465,13 +2679,16 @@ function indexFiles(index, cursor = 0, limit = 100) {
 		additions: file.additions,
 		deletions: file.deletions
 	}));
-	return {
+	const page = {
 		generation: index.generation,
 		returned: files.length,
 		total: index.files.length,
-		nextCursor: end < index.files.length ? end : null,
+		matched: scoped.entries.length,
+		nextCursor: end < scoped.entries.length ? end : null,
 		files
 	};
+	if (path) page.path = path;
+	return page;
 }
 function indexHunks(index, fileIndex, cursor = 0, limit = 100, generation) {
 	if (generation !== void 0 && generation !== index.generation) return {
@@ -2542,11 +2759,17 @@ function indexSlice(index, fileIndex, startRow = 0, maxLines = DEFAULT_SLICE_LIN
 		rows
 	};
 }
-function indexSearch(index, query, fileStart = 0, rowStart = 0, limit = 100, maxBytes = DEFAULT_MAX_BYTES, generation) {
+function indexSearch(index, query, fileStart = 0, rowStart = 0, limit = 100, maxBytes = DEFAULT_MAX_BYTES, generation, path) {
 	if (generation !== void 0 && generation !== index.generation) return {
 		error: `stale generation ${generation}; current generation is ${index.generation}`,
 		status: 409
 	};
+	let matcher;
+	if (path) {
+		const compiled = compilePathspecGlob(path);
+		if ("error" in compiled) return compiled;
+		matcher = compiled;
+	}
 	const q = query.toLowerCase();
 	if (!q) return {
 		generation: index.generation,
@@ -2565,6 +2788,7 @@ function indexSearch(index, query, fileStart = 0, rowStart = 0, limit = 100, max
 	let nextRow = null;
 	outer: for (let fi = Math.max(0, fileStart); fi < index.files.length; fi++) {
 		const file = index.files[fi];
+		if (matcher && !fileMatchesPath(matcher, file.oldPath, file.newPath)) continue;
 		const path = file.newPath ?? file.oldPath ?? "";
 		const pathMatch = path.toLowerCase().includes(q);
 		const rowBegin = fi === fileStart ? Math.max(0, rowStart) : 0;
@@ -3169,9 +3393,21 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 		const n = Number(value);
 		return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : fallback;
 	}
+	function optionalUInt(value) {
+		if (value == null || value === "") return void 0;
+		const n = Number(value);
+		return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : void 0;
+	}
+	function inspectError(c, result) {
+		const body = { error: result.error };
+		if (result.path != null) body.path = result.path;
+		if (result.matches != null) body.matches = result.matches;
+		return c.json(body, result.status);
+	}
 	app.get("/api/diff/summary", async (c) => {
 		const patch = await resolveAgentPatch();
-		const summary = indexSummary(agentDiffCache.getOrBuild(patch));
+		const summary = indexSummary(agentDiffCache.getOrBuild(patch), c.req.query("exclude"));
+		if ("status" in summary) return inspectError(c, summary);
 		if (!prMode) return c.json(summary);
 		const session = await prStore.get();
 		if (!session) return c.json(summary);
@@ -3189,32 +3425,33 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 	});
 	app.get("/api/diff/files", async (c) => {
 		const patch = await resolveAgentPatch();
-		const index = agentDiffCache.getOrBuild(patch);
-		const cursor = parseUInt(c.req.query("cursor"), 0);
-		const limit = parseUInt(c.req.query("limit"), 100);
-		return c.json(indexFiles(index, cursor, limit));
+		const result = indexFiles(agentDiffCache.getOrBuild(patch), parseUInt(c.req.query("cursor"), 0), parseUInt(c.req.query("limit"), 100), c.req.query("path"));
+		if ("status" in result) return inspectError(c, result);
+		return c.json(result);
 	});
 	app.get("/api/diff/hunks", async (c) => {
 		const patch = await resolveAgentPatch();
 		const index = agentDiffCache.getOrBuild(patch);
-		const file = parseUInt(c.req.query("file"), 0);
+		const resolved = resolveInspectFile(index, optionalUInt(c.req.query("file")), c.req.query("path"));
+		if ("status" in resolved) return inspectError(c, resolved);
 		const cursor = parseUInt(c.req.query("cursor"), 0);
 		const limit = parseUInt(c.req.query("limit"), 100);
 		const generationRaw = c.req.query("generation");
-		const result = indexHunks(index, file, cursor, limit, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
-		if ("status" in result) return c.json({ error: result.error }, result.status);
+		const result = indexHunks(index, resolved.fileIndex, cursor, limit, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
+		if ("status" in result) return inspectError(c, result);
 		return c.json(result);
 	});
 	app.get("/api/diff/slice", async (c) => {
 		const patch = await resolveAgentPatch();
 		const index = agentDiffCache.getOrBuild(patch);
-		const file = parseUInt(c.req.query("file"), 0);
+		const resolved = resolveInspectFile(index, optionalUInt(c.req.query("file")), c.req.query("path"));
+		if ("status" in resolved) return inspectError(c, resolved);
 		const start = parseUInt(c.req.query("start"), 0);
 		const maxLines = parseUInt(c.req.query("maxLines"), 120);
 		const maxBytes = parseUInt(c.req.query("maxBytes"), 256 * 1024);
 		const generationRaw = c.req.query("generation");
-		const result = indexSlice(index, file, start, maxLines, maxBytes, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
-		if ("status" in result) return c.json({ error: result.error }, result.status);
+		const result = indexSlice(index, resolved.fileIndex, start, maxLines, maxBytes, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
+		if ("status" in result) return inspectError(c, result);
 		return c.json(result);
 	});
 	app.get("/api/diff/search", async (c) => {
@@ -3226,8 +3463,8 @@ function createApp(clientDir, diffOptsInput = DEFAULTS, commentStore, planStore,
 		const limit = parseUInt(c.req.query("limit"), 100);
 		const maxBytes = parseUInt(c.req.query("maxBytes"), 256 * 1024);
 		const generationRaw = c.req.query("generation");
-		const result = indexSearch(index, q, file, row, limit, maxBytes, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0);
-		if ("status" in result) return c.json({ error: result.error }, result.status);
+		const result = indexSearch(index, q, file, row, limit, maxBytes, generationRaw != null && generationRaw !== "" ? parseUInt(generationRaw, 0) : void 0, c.req.query("path"));
+		if ("status" in result) return inspectError(c, result);
 		return c.json(result);
 	});
 	const resolveFileVersion = async (path, version) => {

package/extensions/pi/index.ts

@@ -45,6 +45,7 @@ const SKILL_NAMES = [
 	"diffing-plan-review",
 	"diffing-pr-address",
 	"diffing-pr-read",
+	"diffing-release",
 	"diffing-review",
 	"diffing-start-review",
 ] as const;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffing",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "local-first CLI for reviewing, navigating, and discussing git diffs with AI",
   "type": "module",
   "license": "MIT",
@@ -56,6 +56,7 @@
     "verify:release-bundle": "node scripts/verify-tui-bundle.mjs",
     "prepublishOnly": "pnpm run verify:release-bundle",
     "version-packages": "changeset version",
+    "release": "node scripts/release.mjs",
     "docs:dev": "pnpm --dir site dev",
     "docs:build": "pnpm --dir site build",
     "docs:preview": "pnpm --dir site preview"