pi-cursor-sdk 0.1.18 → 0.1.20

package/src/cursor-tool-names.ts

@@ -10,6 +10,10 @@ export const CURSOR_REPLAY_LEGACY_TOOL_NAMES = [
 	"cursor_create_plan",
 	"cursor_generate_image",
 	"cursor_mcp",
+	"cursor_sem_search",
+	"cursor_record_screen",
+	"cursor_web_search",
+	"cursor_web_fetch",
 ] as const;
 
 export type CursorReplayLegacyToolName = (typeof CURSOR_REPLAY_LEGACY_TOOL_NAMES)[number];
@@ -25,6 +29,10 @@ const CURSOR_REPLAY_SOURCE_TOOL_NAMES = {
 	cursor_create_plan: "createPlan",
 	cursor_generate_image: "generateImage",
 	cursor_mcp: "MCP",
+	cursor_sem_search: "semSearch",
+	cursor_record_screen: "recordScreen",
+	cursor_web_search: "web search",
+	cursor_web_fetch: "web fetch",
 } as const satisfies Record<CursorReplayLegacyToolName, string>;
 
 const CURSOR_REPLAY_PROMPT_LABELS = {
@@ -37,8 +45,30 @@ const CURSOR_REPLAY_PROMPT_LABELS = {
 	cursor_create_plan: "Cursor plan",
 	cursor_generate_image: "Cursor image generation",
 	cursor_mcp: "Cursor MCP",
+	cursor_sem_search: "Cursor semantic search",
+	cursor_record_screen: "Cursor screen recording",
+	cursor_web_search: "Cursor web search",
+	cursor_web_fetch: "Cursor web fetch",
 } as const satisfies Record<CursorReplayLegacyToolName, string>;
 
+export const CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME = {
+	edit: "cursor_edit",
+	write: "cursor_write",
+	readLints: "cursor_read_lints",
+	delete: "cursor_delete",
+	updateTodos: "cursor_update_todos",
+	task: "cursor_task",
+	createPlan: "cursor_create_plan",
+	generateImage: "cursor_generate_image",
+	mcp: "cursor_mcp",
+	semSearch: "cursor_sem_search",
+	recordScreen: "cursor_record_screen",
+	webSearch: "cursor_web_search",
+	webFetch: "cursor_web_fetch",
+} as const satisfies Record<string, CursorReplayLegacyToolName>;
+
+export type CursorReplayActivityToolName = keyof typeof CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME;
+
 export function isCursorReplayLegacyToolName(toolName: string): toolName is CursorReplayLegacyToolName {
 	return CURSOR_REPLAY_LEGACY_TOOL_NAMES.some((legacyToolName) => legacyToolName === toolName);
 }
@@ -65,3 +95,12 @@ export function getCursorReplayDisplayLabel(toolName: CursorReplayToolName): str
 	if (toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME) return "Cursor activity";
 	return CURSOR_REPLAY_PROMPT_LABELS[toolName];
 }
+
+export function getCursorReplayActivityLabelKey(toolName: string): CursorReplayLegacyToolName | undefined {
+	return CURSOR_REPLAY_ACTIVITY_LABEL_KEYS_BY_TOOL_NAME[toolName as CursorReplayActivityToolName];
+}
+
+export function getCursorReplayActivityTitle(toolName: string): string | undefined {
+	const labelKey = getCursorReplayActivityLabelKey(toolName);
+	return labelKey ? getCursorReplayDisplayLabel(labelKey) : undefined;
+}

package/src/cursor-tool-transcript.ts

@@ -14,6 +14,7 @@ import {
 	formatCursorToolTranscriptFromSpec,
 	type ToolDisplayContext,
 } from "./cursor-transcript-tool-specs.js";
+import { resolveTranscriptToolName } from "./cursor-web-tool-activity.js";
 
 export type { CursorPiToolDisplay } from "./cursor-transcript-utils.js";
 
@@ -29,10 +30,11 @@ export function getCursorCreatePlanText(toolCall: unknown): string | undefined {
 
 function buildToolDisplayContext(toolCall: unknown, options: TranscriptOptions): ToolDisplayContext {
 	const rawName = getToolName(toolCall);
+	const args = getToolArgs(toolCall);
 	return {
 		rawName,
-		name: normalizeToolName(rawName),
-		args: getToolArgs(toolCall),
+		name: resolveTranscriptToolName(rawName, args),
+		args,
 		result: normalizeResult(getToolResult(toolCall)),
 		options,
 	};

package/src/cursor-tool-visibility.ts

@@ -0,0 +1,63 @@
+import { getCursorReplayActivityTitle } from "./cursor-tool-names.js";
+import { getToolArgs, getToolName, normalizeToolName } from "./cursor-transcript-utils.js";
+import { resolveTranscriptToolName } from "./cursor-web-tool-activity.js";
+
+interface CursorToolVisibilityConfig {
+	incompleteTitle?: string;
+	lifecycleTitle?: string;
+	lifecycleEligible?: boolean;
+	fastLocalDiscovery?: boolean;
+}
+
+export interface CursorToolVisibility {
+	args: Record<string, unknown>;
+	displayName: string;
+	normalizedName: string;
+	normalizedKey: string;
+	activityTitle?: string;
+	incompleteTitle?: string;
+	lifecycleTitle?: string;
+	lifecycleEligible: boolean;
+	fastLocalDiscovery: boolean;
+}
+
+const CURSOR_TOOL_VISIBILITY_BY_NAME: Record<string, CursorToolVisibilityConfig> = {
+	read: { incompleteTitle: "Cursor read", fastLocalDiscovery: true },
+	grep: { incompleteTitle: "Cursor grep", fastLocalDiscovery: true },
+	glob: { incompleteTitle: "Cursor find", fastLocalDiscovery: true },
+	ls: { incompleteTitle: "Cursor ls", fastLocalDiscovery: true },
+	shell: { incompleteTitle: "Cursor shell", lifecycleTitle: "Cursor shell", lifecycleEligible: true },
+	task: { lifecycleEligible: true },
+	mcp: { lifecycleEligible: true },
+	generateimage: { lifecycleEligible: true },
+	recordscreen: { lifecycleEligible: true },
+	semsearch: { lifecycleEligible: true },
+	websearch: { lifecycleEligible: true },
+	webfetch: { lifecycleEligible: true },
+	createplan: { lifecycleEligible: true },
+	updatetodos: { lifecycleEligible: true },
+};
+
+export function classifyCursorToolVisibility(toolCall: unknown): CursorToolVisibility {
+	const args = getToolArgs(toolCall);
+	const displayName = resolveTranscriptToolName(getToolName(toolCall), args);
+	const normalizedName = normalizeToolName(displayName);
+	const normalizedKey = normalizedName.toLowerCase();
+	const config = CURSOR_TOOL_VISIBILITY_BY_NAME[normalizedKey];
+	const replayActivityTitle = getCursorReplayActivityTitle(normalizedName);
+	return {
+		args,
+		displayName,
+		normalizedName,
+		normalizedKey,
+		activityTitle: replayActivityTitle ?? config?.incompleteTitle ?? config?.lifecycleTitle,
+		incompleteTitle: replayActivityTitle ?? config?.incompleteTitle,
+		lifecycleTitle: replayActivityTitle ?? config?.lifecycleTitle,
+		lifecycleEligible: config?.lifecycleEligible ?? false,
+		fastLocalDiscovery: config?.fastLocalDiscovery ?? false,
+	};
+}
+
+export function isFastLocalDiscoveryTool(toolCall: unknown): boolean {
+	return classifyCursorToolVisibility(toolCall).fastLocalDiscovery;
+}

package/src/cursor-transcript-tool-formatters.ts

@@ -1,4 +1,6 @@
 import { resolveCursorEditDiff } from "./cursor-edit-diff.js";
+import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+import { extractWebFetchTarget, extractWebSearchQuery } from "./cursor-web-tool-activity.js";
 import { getFirstStringByKeys } from "./cursor-record-utils.js";
 import {
 	asRecord,
@@ -27,6 +29,21 @@ import {
 	type TranscriptOptions,
 } from "./cursor-transcript-utils.js";
 
+export function usesLocalReadPreview(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): boolean {
+	if (result.status === "error") return false;
+	const value = asRecord(result.value);
+	const resultContent = getString(value, "content");
+	if (resultContent && resultContent.length > 0) return false;
+	const rawPath = typeof args.path === "string" ? args.path : undefined;
+	if (!rawPath) return false;
+	const readOptions = {
+		...options,
+		maxChars: options.maxChars ?? DEFAULT_READ_TRANSCRIPT_CHARS,
+		maxLines: options.maxLines ?? DEFAULT_READ_TRANSCRIPT_LINES,
+	};
+	return readFilePreview(rawPath, readOptions) !== undefined;
+}
+
 function getReadContent(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
 	const rawPath = typeof args.path === "string" ? args.path : undefined;
 	const readOptions = {
@@ -57,9 +74,17 @@ export function formatRead(args: Record<string, unknown>, result: NormalizedResu
 	return joinSections(`read ${path}`, limitText(getReadContent(args, result, options), readOptions, totalLines));
 }
 
-export function buildReadDisplayArgs(args: Record<string, unknown>, options: TranscriptOptions): Record<string, unknown> {
+export function buildReadDisplayArgs(
+	args: Record<string, unknown>,
+	options: TranscriptOptions,
+	result?: NormalizedResult,
+): Record<string, unknown> {
 	const rawPath = typeof args.path === "string" ? args.path : undefined;
-	return rawPath ? { ...args, path: formatDisplayPath(rawPath, options.cwd) } : args;
+	const displayArgs = rawPath ? { ...args, path: formatDisplayPath(rawPath, options.cwd) } : args;
+	if (result && usesLocalReadPreview(args, result, options)) {
+		return { ...displayArgs, localReadPreview: true };
+	}
+	return displayArgs;
 }
 
 function buildPathDisplayArgs(args: Record<string, unknown>, options: TranscriptOptions): Record<string, unknown> {
@@ -617,6 +642,153 @@ function describeNonTextMcpContent(entry: unknown): string {
 	return `[${type} omitted]`;
 }
 
+export function summarizeSemSearch(args: Record<string, unknown>): string {
+	const query = getString(args, "query") ?? "semantic search";
+	const targetDirectories = getArray(args, "targetDirectories");
+	const dirHint =
+		targetDirectories && targetDirectories.length > 0
+			? ` (${targetDirectories.length} dir${targetDirectories.length === 1 ? "" : "s"})`
+			: "";
+	return truncateArg(`${query}${dirHint}`);
+}
+
+export function formatSemSearch(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
+	const query = getString(args, "query") ?? "semantic search";
+	const header = `semSearch ${truncateArg(query)}`;
+	if (result.status === "error") return joinSections(header, formatError(result.error));
+
+	const value = asRecord(result.value);
+	const results = getString(value, "results");
+	const targetDirectories = getArray(args, "targetDirectories");
+	const explanation = getString(args, "explanation");
+	const lines: string[] = [];
+	if (explanation?.trim()) lines.push(`Explanation: ${explanation.trim()}`);
+	if (targetDirectories && targetDirectories.length > 0) {
+		const dirs = targetDirectories
+			.map((entry) => (typeof entry === "string" ? entry : stringifyUnknown(entry)))
+			.join(", ");
+		lines.push(`Scope: ${dirs}`);
+	}
+	if (results?.trim()) lines.push(results.trim());
+	const body = lines.length > 0 ? lines.join("\n\n") : stringifyUnknown(result.value);
+	return joinSections(header, limitText(body, options));
+}
+
+function formatRecordScreenMode(mode: string | undefined): string {
+	switch (mode) {
+		case "START_RECORDING":
+			return "start recording";
+		case "SAVE_RECORDING":
+			return "save recording";
+		case "DISCARD_RECORDING":
+			return "discard recording";
+		default:
+			return mode ?? "record screen";
+	}
+}
+
+function formatRecordingDurationMs(ms: number | undefined): string | undefined {
+	if (ms === undefined || !Number.isFinite(ms) || ms < 0) return undefined;
+	if (ms < 1000) return `${Math.round(ms)}ms`;
+	const seconds = ms / 1000;
+	return seconds < 60 ? `${seconds.toFixed(1)}s` : `${Math.floor(seconds / 60)}m ${Math.round(seconds % 60)}s`;
+}
+
+export function summarizeRecordScreen(
+	args: Record<string, unknown>,
+	result: NormalizedResult,
+	options: TranscriptOptions,
+): string {
+	const mode = getString(args, "mode");
+	if (result.status === "error") return formatRecordScreenMode(mode);
+	const value = asRecord(result.value);
+	const path = getString(value, "path");
+	const displayPath = path ? formatDisplayPath(path, options.cwd) : undefined;
+	const duration = formatRecordingDurationMs(getNumber(value, "recordingDurationMs"));
+	const modeLabel = formatRecordScreenMode(mode);
+	if (displayPath && duration) return `${displayPath} · ${duration}`;
+	if (displayPath) return displayPath;
+	if (duration) return `${modeLabel} · ${duration}`;
+	return modeLabel;
+}
+
+export function formatRecordScreen(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
+	const mode = getString(args, "mode");
+	const header = `recordScreen ${formatRecordScreenMode(mode)}`;
+	if (result.status === "error") return joinSections(header, formatError(result.error));
+
+	const value = asRecord(result.value);
+	const path = getString(value, "path");
+	const displayPath = path ? formatDisplayPath(path, options.cwd) : undefined;
+	const duration = formatRecordingDurationMs(getNumber(value, "recordingDurationMs"));
+	const wasCancelled = getBoolean(value, "wasPriorRecordingCancelled");
+	const lines: string[] = [];
+	if (displayPath) lines.push(`Recording: ${displayPath}`);
+	if (duration) lines.push(`Duration: ${duration}`);
+	if (wasCancelled === true) lines.push("Prior recording cancelled.");
+	if (lines.length === 0) {
+		if (mode === "START_RECORDING") lines.push("Recording started.");
+		else if (mode === "DISCARD_RECORDING") lines.push("Recording discarded.");
+		else lines.push("Screen recording updated.");
+	}
+	return joinSections(header, lines.join("\n"));
+}
+
+export function getMcpResultPreview(result: NormalizedResult): string | undefined {
+	if (result.status === "error") return undefined;
+	const value = asRecord(result.value);
+	const content = getArray(value, "content") ?? [];
+	for (const entry of content) {
+		const text = getMcpContentText(entry);
+		if (text) {
+			const line = firstNonEmptyLine(text);
+			if (line) return truncateArg(scrubSensitiveText(line), 120);
+		}
+		const summary = describeNonTextMcpContent(entry);
+		if (summary) return summary;
+	}
+	return undefined;
+}
+
+export function summarizeMcp(args: Record<string, unknown>, result: NormalizedResult): string {
+	const toolName = truncateArg(getString(args, "toolName") ?? "mcp");
+	const preview = getMcpResultPreview(result);
+	return preview && preview !== toolName ? `${toolName} · ${preview}` : toolName;
+}
+
+function formatWebToolBody(
+	toolLabel: string,
+	args: Record<string, unknown>,
+	result: NormalizedResult,
+	options: TranscriptOptions,
+	summaryArg: string | undefined,
+): string {
+	if (result.status === "error") return joinSections(toolLabel, formatError(result.error));
+	const summary = summaryArg ? `${summaryArg}\n\n` : "";
+	const value = asRecord(result.value);
+	const isError = getBoolean(value, "isError");
+	const content = getArray(value, "content") ?? [];
+	const text = content
+		.map((entry) => getMcpContentText(entry))
+		.filter((entry): entry is string => Boolean(entry))
+		.join("\n");
+	const contentSummary = content.length > 0 ? content.map(describeNonTextMcpContent).join("\n") : stringifyUnknown(result.value);
+	const body = `${isError ? "[tool error]\n" : ""}${text || contentSummary}`;
+	return joinSections(toolLabel, limitText(`${summary}${body}`.trim(), options));
+}
+
+export function formatWebSearch(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
+	const query = extractWebSearchQuery(args);
+	const header = query ? `web search ${query}` : "web search";
+	return formatWebToolBody(header, args, result, options, undefined);
+}
+
+export function formatWebFetch(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
+	const target = extractWebFetchTarget(args);
+	const header = target ? `web fetch ${target}` : "web fetch";
+	return formatWebToolBody(header, args, result, options, undefined);
+}
+
 export function formatMcp(args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
 	const toolName = typeof args.toolName === "string" ? args.toolName : "mcp";
 	if (result.status === "error") return joinSections(toolName, formatError(result.error));
@@ -633,9 +805,60 @@ export function formatMcp(args: Record<string, unknown>, result: NormalizedResul
 	return joinSections(toolName, limitText(body, options));
 }
 
+const UNKNOWN_TOOL_FALLBACK_MAX_ARGS = 8;
+const UNKNOWN_TOOL_FALLBACK_MAX_CHARS = 240;
+const UNKNOWN_TOOL_FALLBACK_MAX_LINES = 6;
+
+function summarizeUnknownToolArgValue(value: unknown): string {
+	if (typeof value === "string") return truncateArg(value);
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) {
+		const preview = value.slice(0, 3).map((entry) => summarizeUnknownToolArgValue(entry)).join(", ");
+		const omitted = value.length - Math.min(value.length, 3);
+		return omitted > 0 ? `[${preview}, +${omitted} more]` : `[${preview}]`;
+	}
+	return truncateArg(stringifyUnknown(value).replace(/\s+/g, " "));
+}
+
+function summarizeUnknownToolArgs(args: Record<string, unknown>): string {
+	const entries = Object.entries(args).slice(0, UNKNOWN_TOOL_FALLBACK_MAX_ARGS);
+	if (entries.length === 0) return "";
+	const parts = entries.map(([key, value]) => `${key}=${summarizeUnknownToolArgValue(value)}`);
+	const omitted = Object.keys(args).length - entries.length;
+	const body = parts.join(", ");
+	return omitted > 0 ? `${body} (+${omitted} more)` : body;
+}
+
+function summarizeUnknownToolResult(value: unknown, options: TranscriptOptions): string {
+	const text = stringifyUnknown(value).trim();
+	if (!text) return "";
+	return limitText(text.replace(/\s+/g, " "), {
+		...options,
+		maxChars: options.maxChars ?? UNKNOWN_TOOL_FALLBACK_MAX_CHARS,
+		maxLines: options.maxLines ?? UNKNOWN_TOOL_FALLBACK_MAX_LINES,
+	});
+}
+
+function summarizeUnknownToolError(error: unknown, options: TranscriptOptions): string {
+	const text = formatError(error).trim();
+	if (!text) return "Error";
+	return limitText(text, {
+		...options,
+		maxChars: options.maxChars ?? UNKNOWN_TOOL_FALLBACK_MAX_CHARS,
+		maxLines: options.maxLines ?? UNKNOWN_TOOL_FALLBACK_MAX_LINES,
+	});
+}
+
 export function formatFallback(name: string, args: Record<string, unknown>, result: NormalizedResult, options: TranscriptOptions): string {
 	const header = name === "unknown" ? "Cursor tool" : name;
-	if (result.status === "error") return joinSections(header, formatError(result.error));
-	const argsText = Object.keys(args).length > 0 ? `${stringifyUnknown(args)}\n\n` : "";
-	return joinSections(header, limitText(`${argsText}${stringifyUnknown(result.value)}`.trim(), options));
+	if (result.status === "error") {
+		const argsSummary = summarizeUnknownToolArgs(args);
+		const errorSummary = summarizeUnknownToolError(result.error, options);
+		const body = [argsSummary, errorSummary].filter(Boolean).join("\n\n");
+		return joinSections(header, body ? limitText(body, options) : undefined);
+	}
+	const argsSummary = summarizeUnknownToolArgs(args);
+	const resultSummary = summarizeUnknownToolResult(result.value, options);
+	const body = [argsSummary, resultSummary].filter(Boolean).join("\n\n");
+	return joinSections(header, body ? limitText(body, options) : undefined);
 }