gsd-pi 2.16.0 → 2.18.0

package/packages/pi-coding-agent/src/core/tools/edit-diff.test.ts

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+
+import {
+	computeEditDiff,
+	fuzzyFindText,
+	generateDiffString,
+	normalizeForFuzzyMatch,
+} from "./edit-diff.js";
+
+describe("edit-diff", () => {
+	it("normalizes quotes, dashes, spaces, and trailing whitespace", () => {
+		const input = "“hello”\u00A0world — test  \nnext\t\t\n";
+		assert.equal(normalizeForFuzzyMatch(input), "\"hello\" world - test\nnext\n");
+	});
+
+	it("falls back to fuzzy matching when unicode punctuation differs", () => {
+		const result = fuzzyFindText("const title = “Hello”;\n", "const title = \"Hello\";\n");
+		assert.equal(result.found, true);
+		assert.equal(result.usedFuzzyMatch, true);
+		assert.equal(result.contentForReplacement, "const title = \"Hello\";\n");
+	});
+
+	it("renders numbered diffs with the first changed line", () => {
+		const result = generateDiffString("line 1\nline 2\nline 3\n", "line 1\nline two\nline 3\n");
+		assert.equal(result.firstChangedLine, 2);
+		assert.match(result.diff, /-2 line 2/);
+		assert.match(result.diff, /\+2 line two/);
+	});
+
+	it("respects contextLines and inserts separators for distant changes", () => {
+		const lines = Array.from({ length: 20 }, (_, i) => `line ${i + 1}`);
+		const oldContent = lines.join("\n") + "\n";
+		const modified = [...lines];
+		modified[1] = "changed 2"; // line 2
+		modified[17] = "changed 18"; // line 18
+		const newContent = modified.join("\n") + "\n";
+
+		const result = generateDiffString(oldContent, newContent, 2);
+		// Should contain separator between the two distant change regions
+		assert.match(result.diff, /\.\.\./);
+		// Should NOT contain lines far from changes (e.g. line 10)
+		assert.doesNotMatch(result.diff, /line 10/);
+		// Should contain the changed lines
+		assert.match(result.diff, /changed 2/);
+		assert.match(result.diff, /changed 18/);
+	});
+
+	it("handles large files without OOM by falling back to linear diff", () => {
+		// Create files large enough to exceed the DP threshold
+		const lineCount = 3000;
+		const oldLines = Array.from({ length: lineCount }, (_, i) => `line ${i}`);
+		const newLines = [...oldLines];
+		newLines[1500] = "CHANGED";
+		const result = generateDiffString(oldLines.join("\n") + "\n", newLines.join("\n") + "\n");
+		assert.ok(result.firstChangedLine !== undefined);
+		assert.match(result.diff, /CHANGED/);
+	});
+
+	it("computes diffs for preview without native helpers", async () => {
+		const dir = mkdtempSync(join(tmpdir(), "edit-diff-test-"));
+		try {
+			const file = join(dir, "sample.ts");
+			writeFileSync(file, "const title = “Hello”;\n", "utf-8");
+
+			const result = await computeEditDiff(
+				file,
+				"const title = \"Hello\";\n",
+				"const title = \"Hi\";\n",
+				dir,
+			);
+
+			assert.ok(!("error" in result), "expected a diff result");
+			if (!("error" in result)) {
+				assert.equal(result.firstChangedLine, 1);
+				assert.match(result.diff, /\+1 const title = "Hi";/);
+			}
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});

package/packages/pi-coding-agent/src/core/tools/edit-diff.ts

@@ -2,15 +2,11 @@
  * Shared diff computation utilities for the edit tool.
  * Used by both edit.ts (for execution) and tool-execution.ts (for preview rendering).
  *
- * Hot-path functions (fuzzyFindText, normalizeForFuzzyMatch, generateDiffString)
- * delegate to the native Rust engine for performance on large files.
+ * These helpers intentionally stay in JavaScript. Issue #453 showed that
+ * post-tool preview paths must not depend on the native addon because a native
+ * hang there can wedge the entire interactive session after a successful tool run.
  */
 
-import {
-	fuzzyFindText as nativeFuzzyFindText,
-	generateDiff as nativeGenerateDiff,
-	normalizeForFuzzyMatch as nativeNormalizeForFuzzyMatch,
-} from "@gsd/native";
 import { constants } from "fs";
 import { access, readFile } from "fs/promises";
 import { resolveToCwd } from "./path-utils.js";
@@ -32,14 +28,23 @@ export function restoreLineEndings(text: string, ending: "\r\n" | "\n"): string
 }
 
 /**
- * Normalize text for fuzzy matching (native Rust implementation).
+ * Normalize text for fuzzy matching.
  * - Strip trailing whitespace from each line
  * - Normalize smart quotes to ASCII equivalents
  * - Normalize Unicode dashes/hyphens to ASCII hyphen
  * - Normalize special Unicode spaces to regular space
  */
 export function normalizeForFuzzyMatch(text: string): string {
-	return nativeNormalizeForFuzzyMatch(text);
+	return text
+		.replace(/\r\n/g, "\n")
+		.replace(/\r/g, "\n")
+		.replace(/[“”]/g, '"')
+		.replace(/[‘’]/g, "'")
+		.replace(/[‐‑‒–—−]/g, "-")
+		.replace(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g, " ")
+		.split("\n")
+		.map((line) => line.replace(/[ \t]+$/g, ""))
+		.join("\n");
 }
 
 export interface FuzzyMatchResult {
@@ -59,14 +64,44 @@ export interface FuzzyMatchResult {
 }
 
 /**
- * Find oldText in content, trying exact match first, then fuzzy match
- * (native Rust implementation).
+ * Find oldText in content, trying exact match first, then fuzzy match.
  *
  * When fuzzy matching is used, the returned contentForReplacement is the
  * fuzzy-normalized version of the content.
  */
 export function fuzzyFindText(content: string, oldText: string): FuzzyMatchResult {
-	return nativeFuzzyFindText(content, oldText);
+	const exactIndex = content.indexOf(oldText);
+	if (exactIndex !== -1) {
+		return {
+			found: true,
+			index: exactIndex,
+			matchLength: oldText.length,
+			usedFuzzyMatch: false,
+			contentForReplacement: content,
+		};
+	}
+
+	const normalizedContent = normalizeForFuzzyMatch(content);
+	const normalizedOldText = normalizeForFuzzyMatch(oldText);
+	const fuzzyIndex = normalizedContent.indexOf(normalizedOldText);
+
+	if (fuzzyIndex === -1) {
+		return {
+			found: false,
+			index: -1,
+			matchLength: 0,
+			usedFuzzyMatch: false,
+			contentForReplacement: content,
+		};
+	}
+
+	return {
+		found: true,
+		index: fuzzyIndex,
+		matchLength: normalizedOldText.length,
+		usedFuzzyMatch: true,
+		contentForReplacement: normalizedContent,
+	};
 }
 
 /** Strip UTF-8 BOM if present, return both the BOM (if any) and the text without it */
@@ -75,20 +110,81 @@ export function stripBom(content: string): { bom: string; text: string } {
 }
 
 /**
- * Generate a unified diff string with line numbers and context
- * (native Rust implementation using Myers' algorithm via the `similar` crate).
+ * Generate a unified diff string with line numbers and context.
  *
  * Returns both the diff string and the first changed line number (in the new file).
+ * Only lines within `contextLines` of a change are included (like unified diff).
  */
 export function generateDiffString(
 	oldContent: string,
 	newContent: string,
 	contextLines = 4,
 ): { diff: string; firstChangedLine: number | undefined } {
-	const result = nativeGenerateDiff(oldContent, newContent, contextLines);
+	const ops = buildLineDiff(oldContent, newContent);
+	let firstChangedLine: number | undefined;
+
+	// First pass: assign line numbers and find changed indices
+	const annotated: { op: LineDiffOp; oldLine: number; newLine: number }[] = [];
+	let oldLine = 1;
+	let newLine = 1;
+	const changedIndices: number[] = [];
+
+	for (let idx = 0; idx < ops.length; idx++) {
+		const op = ops[idx];
+		annotated.push({ op, oldLine, newLine });
+
+		if (op.type !== "context") {
+			changedIndices.push(idx);
+			if (firstChangedLine === undefined) {
+				firstChangedLine = newLine;
+			}
+		}
+
+		if (op.type === "remove") {
+			oldLine += 1;
+		} else if (op.type === "add") {
+			newLine += 1;
+		} else {
+			oldLine += 1;
+			newLine += 1;
+		}
+	}
+
+	// Build set of indices to include (changes + surrounding context)
+	const includeSet = new Set<number>();
+	for (const ci of changedIndices) {
+		for (let k = Math.max(0, ci - contextLines); k <= Math.min(ops.length - 1, ci + contextLines); k++) {
+			includeSet.add(k);
+		}
+	}
+
+	const maxLine = Math.max(oldLine - 1, newLine - 1, 1);
+	const lineNumberWidth = String(maxLine).length;
+	const rendered: string[] = [];
+	let lastIncluded = -1;
+
+	for (let idx = 0; idx < annotated.length; idx++) {
+		if (!includeSet.has(idx)) continue;
+
+		// Insert separator when there's a gap between included regions
+		if (lastIncluded !== -1 && idx > lastIncluded + 1) {
+			rendered.push("...");
+		}
+		lastIncluded = idx;
+
+		const { op, oldLine: ol, newLine: nl } = annotated[idx];
+		if (op.type === "context") {
+			rendered.push(` ${String(nl).padStart(lineNumberWidth, " ")} ${op.line}`);
+		} else if (op.type === "remove") {
+			rendered.push(`-${String(ol).padStart(lineNumberWidth, " ")} ${op.line}`);
+		} else {
+			rendered.push(`+${String(nl).padStart(lineNumberWidth, " ")} ${op.line}`);
+		}
+	}
+
 	return {
-		diff: result.diff,
-		firstChangedLine: result.firstChangedLine ?? undefined,
+		diff: rendered.join("\n"),
+		firstChangedLine,
 	};
 }
 
@@ -101,6 +197,138 @@ export interface EditDiffError {
 	error: string;
 }
 
+type LineDiffOp =
+	| { type: "context"; line: string }
+	| { type: "remove"; line: string }
+	| { type: "add"; line: string };
+
+function splitLines(text: string): string[] {
+	const lines = text.split("\n");
+	if (lines.length > 0 && lines.at(-1) === "") {
+		lines.pop();
+	}
+	return lines;
+}
+
+/**
+ * Maximum number of cells (oldLines * newLines) before we switch from the
+ * full LCS DP algorithm to a simpler linear-scan diff. This prevents OOM
+ * on large files (e.g. 10k lines would need a 100M-cell matrix).
+ */
+const MAX_DP_CELLS = 4_000_000; // ~32 MB for 64-bit numbers
+
+function buildLineDiff(oldContent: string, newContent: string): LineDiffOp[] {
+	const oldLines = splitLines(oldContent);
+	const newLines = splitLines(newContent);
+
+	const cells = (oldLines.length + 1) * (newLines.length + 1);
+	if (cells > MAX_DP_CELLS) {
+		return buildLineDiffLinear(oldLines, newLines);
+	}
+
+	return buildLineDiffLCS(oldLines, newLines);
+}
+
+/**
+ * Full LCS-based diff using O(n*m) DP table. Produces optimal diffs but
+ * is only safe for files where n*m <= MAX_DP_CELLS.
+ */
+function buildLineDiffLCS(oldLines: string[], newLines: string[]): LineDiffOp[] {
+	const dp: number[][] = Array.from({ length: oldLines.length + 1 }, () =>
+		Array<number>(newLines.length + 1).fill(0),
+	);
+
+	for (let i = oldLines.length - 1; i >= 0; i--) {
+		for (let j = newLines.length - 1; j >= 0; j--) {
+			if (oldLines[i] === newLines[j]) {
+				dp[i][j] = dp[i + 1][j + 1] + 1;
+			} else {
+				dp[i][j] = Math.max(dp[i + 1][j], dp[i][j + 1]);
+			}
+		}
+	}
+
+	const ops: LineDiffOp[] = [];
+	let i = 0;
+	let j = 0;
+
+	while (i < oldLines.length && j < newLines.length) {
+		if (oldLines[i] === newLines[j]) {
+			ops.push({ type: "context", line: oldLines[i] });
+			i += 1;
+			j += 1;
+			continue;
+		}
+
+		if (dp[i + 1][j] >= dp[i][j + 1]) {
+			ops.push({ type: "remove", line: oldLines[i] });
+			i += 1;
+		} else {
+			ops.push({ type: "add", line: newLines[j] });
+			j += 1;
+		}
+	}
+
+	while (i < oldLines.length) {
+		ops.push({ type: "remove", line: oldLines[i] });
+		i += 1;
+	}
+
+	while (j < newLines.length) {
+		ops.push({ type: "add", line: newLines[j] });
+		j += 1;
+	}
+
+	return ops;
+}
+
+/**
+ * Linear-time fallback diff for large files. Matches common prefix/suffix,
+ * then treats the remaining middle as a bulk remove+add. Not optimal but
+ * O(n+m) in both time and space.
+ */
+function buildLineDiffLinear(oldLines: string[], newLines: string[]): LineDiffOp[] {
+	const ops: LineDiffOp[] = [];
+
+	// Match common prefix
+	let prefixLen = 0;
+	const minLen = Math.min(oldLines.length, newLines.length);
+	while (prefixLen < minLen && oldLines[prefixLen] === newLines[prefixLen]) {
+		prefixLen++;
+	}
+
+	// Match common suffix (not overlapping with prefix)
+	let suffixLen = 0;
+	while (
+		suffixLen < minLen - prefixLen &&
+		oldLines[oldLines.length - 1 - suffixLen] === newLines[newLines.length - 1 - suffixLen]
+	) {
+		suffixLen++;
+	}
+
+	// Emit prefix context
+	for (let i = 0; i < prefixLen; i++) {
+		ops.push({ type: "context", line: oldLines[i] });
+	}
+
+	// Emit removed lines from the middle
+	for (let i = prefixLen; i < oldLines.length - suffixLen; i++) {
+		ops.push({ type: "remove", line: oldLines[i] });
+	}
+
+	// Emit added lines from the middle
+	for (let j = prefixLen; j < newLines.length - suffixLen; j++) {
+		ops.push({ type: "add", line: newLines[j] });
+	}
+
+	// Emit suffix context
+	for (let i = oldLines.length - suffixLen; i < oldLines.length; i++) {
+		ops.push({ type: "context", line: oldLines[i] });
+	}
+
+	return ops;
+}
+
 /**
  * Compute the diff for an edit operation without applying it.
  * Used for preview rendering in the TUI before the tool executes.

package/packages/pi-coding-agent/src/index.ts

@@ -143,7 +143,11 @@ export {
 // Footer data provider (git branch + extension statuses - data not otherwise available to extensions)
 export type { ReadonlyFooterDataProvider } from "./core/footer-data-provider.js";
 export { convertToLlm } from "./core/messages.js";
+export { ModelDiscoveryCache } from "./core/discovery-cache.js";
+export type { DiscoveredModel, DiscoveryResult, ProviderDiscoveryAdapter } from "./core/model-discovery.js";
+export { getDiscoverableProviders, getDiscoveryAdapter } from "./core/model-discovery.js";
 export { ModelRegistry } from "./core/model-registry.js";
+export { ModelsJsonWriter } from "./core/models-json-writer.js";
 export type {
 	PackageManager,
 	PathMetadata,
@@ -307,6 +311,7 @@ export {
 	LoginDialogComponent,
 	ModelSelectorComponent,
 	OAuthSelectorComponent,
+	ProviderManagerComponent,
 	type RenderDiffOptions,
 	rawKeyHint,
 	renderDiff,

package/packages/pi-coding-agent/src/main.ts

@@ -11,7 +11,7 @@ import { createInterface } from "readline";
 import { type Args, parseArgs, printHelp } from "./cli/args.js";
 import { selectConfig } from "./cli/config-selector.js";
 import { processFileArguments } from "./cli/file-processor.js";
-import { listModels } from "./cli/list-models.js";
+import { discoverAndPrintModels, listModels } from "./cli/list-models.js";
 import { selectSession } from "./cli/session-picker.js";
 import { APP_NAME, getAgentDir, getModelsPath, VERSION } from "./config.js";
 import { AuthStorage } from "./core/auth-storage.js";
@@ -660,9 +660,26 @@ export async function main(args: string[]) {
 		process.exit(0);
 	}
 
+	if (parsed.addProvider) {
+		const { ModelsJsonWriter } = await import("./core/models-json-writer.js");
+		const writer = new ModelsJsonWriter();
+		writer.setProvider(parsed.addProvider, {
+			baseUrl: parsed.addProviderBaseUrl,
+			apiKey: parsed.apiKey,
+		});
+		console.log(`Provider "${parsed.addProvider}" added to models.json`);
+		process.exit(0);
+	}
+
+	if (parsed.discoverModels !== undefined) {
+		const provider = typeof parsed.discoverModels === "string" ? parsed.discoverModels : undefined;
+		await discoverAndPrintModels(modelRegistry, provider);
+		process.exit(0);
+	}
+
 	if (parsed.listModels !== undefined) {
 		const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
-		await listModels(modelRegistry, searchPattern);
+		await listModels(modelRegistry, { searchPattern, discover: parsed.discover });
 		process.exit(0);
 	}
 

package/packages/pi-coding-agent/src/modes/interactive/components/index.ts

@@ -18,6 +18,7 @@ export { appKey, appKeyHint, editorKey, keyHint, rawKeyHint } from "./keybinding
 export { LoginDialogComponent } from "./login-dialog.js";
 export { ModelSelectorComponent } from "./model-selector.js";
 export { OAuthSelectorComponent } from "./oauth-selector.js";
+export { ProviderManagerComponent } from "./provider-manager.js";
 export { type ModelsCallbacks, type ModelsConfig, ScopedModelsSelectorComponent } from "./scoped-models-selector.js";
 export { SessionSelectorComponent } from "./session-selector.js";
 export { type SettingsCallbacks, type SettingsConfig, SettingsSelectorComponent } from "./settings-selector.js";

package/packages/pi-coding-agent/src/modes/interactive/components/model-selector.ts

@@ -160,7 +160,7 @@ export class ModelSelectorComponent extends Container implements Focusable {
 
 		// Load available models (built-in models still work even if models.json failed)
 		try {
-			const availableModels = await this.modelRegistry.getAvailable();
+			const availableModels = this.modelRegistry.getAvailable();
 			models = availableModels.map((model: Model<any>) => ({
 				provider: model.provider,
 				id: model.id,

package/packages/pi-coding-agent/src/modes/interactive/components/provider-manager.ts

@@ -0,0 +1,163 @@
+/**
+ * TUI component for managing provider configurations.
+ * Shows providers with auth status, discovery support, and model counts.
+ */
+
+import {
+	Container,
+	type Focusable,
+	getEditorKeybindings,
+	Spacer,
+	Text,
+	type TUI,
+} from "@gsd/pi-tui";
+import type { AuthStorage } from "../../../core/auth-storage.js";
+import { getDiscoverableProviders } from "../../../core/model-discovery.js";
+import type { ModelRegistry } from "../../../core/model-registry.js";
+import { theme } from "../theme/theme.js";
+import { rawKeyHint } from "./keybinding-hints.js";
+
+interface ProviderInfo {
+	name: string;
+	hasAuth: boolean;
+	supportsDiscovery: boolean;
+	modelCount: number;
+}
+
+export class ProviderManagerComponent extends Container implements Focusable {
+	private _focused = false;
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+	}
+
+	private providers: ProviderInfo[] = [];
+	private selectedIndex = 0;
+	private listContainer: Container;
+	private tui: TUI;
+	private authStorage: AuthStorage;
+	private modelRegistry: ModelRegistry;
+	private onDone: () => void;
+	private onDiscover: (provider: string) => void;
+
+	constructor(
+		tui: TUI,
+		authStorage: AuthStorage,
+		modelRegistry: ModelRegistry,
+		onDone: () => void,
+		onDiscover: (provider: string) => void,
+	) {
+		super();
+
+		this.tui = tui;
+		this.authStorage = authStorage;
+		this.modelRegistry = modelRegistry;
+		this.onDone = onDone;
+		this.onDiscover = onDiscover;
+
+		// Header
+		this.addChild(new Text(theme.fg("accent", "Provider Manager"), 0, 0));
+		this.addChild(new Spacer(1));
+
+		// Hints
+		const hints = [
+			rawKeyHint("d", "discover"),
+			rawKeyHint("r", "remove auth"),
+			rawKeyHint("esc", "close"),
+		].join("  ");
+		this.addChild(new Text(hints, 0, 0));
+		this.addChild(new Spacer(1));
+
+		// List
+		this.listContainer = new Container();
+		this.addChild(this.listContainer);
+
+		this.loadProviders();
+		this.updateList();
+	}
+
+	private loadProviders(): void {
+		const discoverableSet = new Set(getDiscoverableProviders());
+		const allModels = this.modelRegistry.getAll();
+
+		// Group models by provider
+		const providerModelCounts = new Map<string, number>();
+		for (const model of allModels) {
+			providerModelCounts.set(model.provider, (providerModelCounts.get(model.provider) ?? 0) + 1);
+		}
+
+		// Build provider list from all known providers
+		const providerNames = new Set([
+			...providerModelCounts.keys(),
+			...discoverableSet,
+		]);
+
+		this.providers = Array.from(providerNames)
+			.sort()
+			.map((name) => ({
+				name,
+				hasAuth: this.authStorage.hasAuth(name),
+				supportsDiscovery: discoverableSet.has(name),
+				modelCount: providerModelCounts.get(name) ?? 0,
+			}));
+	}
+
+	private updateList(): void {
+		this.listContainer.clear();
+
+		for (let i = 0; i < this.providers.length; i++) {
+			const p = this.providers[i];
+			const isSelected = i === this.selectedIndex;
+
+			const authBadge = p.hasAuth ? theme.fg("success", "[auth]") : theme.fg("muted", "[no auth]");
+			const discoveryBadge = p.supportsDiscovery ? theme.fg("accent", "[discovery]") : "";
+			const countBadge = theme.fg("muted", `(${p.modelCount} models)`);
+
+			const prefix = isSelected ? theme.fg("accent", "> ") : "  ";
+			const nameText = isSelected ? theme.fg("accent", p.name) : p.name;
+
+			const parts = [prefix, nameText, " ", authBadge];
+			if (discoveryBadge) parts.push(" ", discoveryBadge);
+			parts.push(" ", countBadge);
+
+			this.listContainer.addChild(new Text(parts.join(""), 0, 0));
+		}
+
+		if (this.providers.length === 0) {
+			this.listContainer.addChild(new Text(theme.fg("muted", "  No providers configured"), 0, 0));
+		}
+	}
+
+	handleInput(keyData: string): void {
+		const kb = getEditorKeybindings();
+
+		if (kb.matches(keyData, "selectUp")) {
+			if (this.providers.length === 0) return;
+			this.selectedIndex = this.selectedIndex === 0 ? this.providers.length - 1 : this.selectedIndex - 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "selectDown")) {
+			if (this.providers.length === 0) return;
+			this.selectedIndex = this.selectedIndex === this.providers.length - 1 ? 0 : this.selectedIndex + 1;
+			this.updateList();
+			this.tui.requestRender();
+		} else if (kb.matches(keyData, "selectCancel")) {
+			this.onDone();
+		} else if (keyData === "d" || keyData === "D") {
+			const provider = this.providers[this.selectedIndex];
+			if (provider?.supportsDiscovery) {
+				this.onDiscover(provider.name);
+			}
+		} else if (keyData === "r" || keyData === "R") {
+			const provider = this.providers[this.selectedIndex];
+			if (provider?.hasAuth) {
+				this.authStorage.remove(provider.name);
+				this.loadProviders();
+				this.updateList();
+				this.tui.requestRender();
+			}
+		}
+	}
+}