pi-cursor-sdk 0.1.62 → 0.3.6

package/dist/cursor-tool-manifest.js

@@ -0,0 +1,34 @@
+import { parseEnvBoolean } from "./cursor-env-boolean.js";
+export const CURSOR_TOOL_MANIFEST_ENV = "PI_CURSOR_TOOL_MANIFEST";
+/**
+ * Representative @cursor/sdk@1.0.27 local-agent ToolType values; actual exposure can vary by run.
+ * See docs/cursor-native-tool-replay.md#sdk-tooltype-replay-matrix.
+ */
+export const CURSOR_HOST_TOOL_MANIFEST_SUMMARY = "read/shell/search/edit/write and other host tools when Cursor exposes them";
+export function resolveCursorToolManifestEnabled(env = process.env) {
+    return parseEnvBoolean(env[CURSOR_TOOL_MANIFEST_ENV], true);
+}
+export function buildCursorToolManifestText(options = {}) {
+    const piBridgeEnabled = options.piBridgeEnabled ?? true;
+    const includePiBridgeGuidance = options.includePiBridgeGuidance !== false;
+    const lines = [
+        "Callable tool surfaces this run:",
+        `- Cursor host/MCP: ${CURSOR_HOST_TOOL_MANIFEST_SUMMARY}; configured MCP depends on Cursor settings.`,
+        "- Pi tool toggles affect pi tools/bridge exposure only; they do not disable Cursor host/configured MCP tools.",
+    ];
+    const bridgeTools = includePiBridgeGuidance ? options.bridgeSnapshot?.tools ?? [] : [];
+    if (includePiBridgeGuidance) {
+        if (!piBridgeEnabled) {
+            lines.push("- Pi bridge: disabled (PI_CURSOR_PI_TOOL_BRIDGE=0).");
+        }
+        else if (bridgeTools.length === 0) {
+            lines.push("- Pi bridge: no pi__* tools exposed this run.");
+        }
+        else {
+            const names = [...bridgeTools.map((tool) => tool.mcpToolName)].sort().join(", ");
+            lines.push(`- Pi bridge: call exposed pi__* MCP names (${names}); pi shows real pi names.`);
+        }
+    }
+    lines.push("- Not callable: cursor-replay-* IDs, pi history names, transcript labels.");
+    return lines.join("\n");
+}

package/dist/cursor-tool-presentation-registry.js

@@ -0,0 +1,305 @@
+/**
+ * Canonical Cursor tool presentation metadata.
+ * Names, labels, visibility, replay, lifecycle, web remapping, and alias normalization
+ * derive from this registry — do not duplicate tool lists in sibling modules.
+ */
+import { formatReplaySemSearchQuery, readCursorReplaySummaryString, summarizeReplayGenericActivity, summarizeReplayMcp, summarizeReplayPath, summarizeReplayPlan, summarizeReplayReadLints, summarizeReplayRecordScreen, summarizeReplayTask, summarizeReplayTodoCount, withActivitySummaryFallback, } from "./cursor-replay-summary-args.js";
+import { truncateCursorDisplayLine } from "./cursor-display-text.js";
+import { getCursorTaskActivityTitle } from "./cursor-task-presentation.js";
+import { buildCreatePlanReplaySummaryArgs, buildDeleteReplayDetailFields, buildDeleteReplaySummaryArgs, buildGenerateImageReplayDetailFields, buildGenerateImageReplaySummaryArgs, buildMcpReplaySummaryArgs, buildReadLintsReplaySummaryArgs, buildRecordScreenReplaySummaryArgs, buildSemSearchReplaySummaryArgs, buildTaskReplaySummaryArgs, buildTodoReplaySummaryArgs, buildWebFetchReplaySummaryArgs, buildWebSearchReplaySummaryArgs, } from "./cursor-replay-activity-builders.js";
+import { CURSOR_REPLAY_SOURCE_TOOL_NAMES } from "./cursor-replay-source-names.js";
+export const CURSOR_REPLAY_ACTIVITY_TOOL_NAME = "cursor";
+const EMPTY_REPLAY_DETAIL_FIELDS = () => ({});
+const COLLAPSED_REPLAY_DETAIL_FIELDS = () => ({ collapseDetailsByDefault: true });
+const WEB_SEARCH_NAME_PATTERN = /^(?:web[-_ ]?search|search[-_ ]?web|websearch|browser[-_ ]?search)$/i;
+const WEB_FETCH_NAME_PATTERN = /^(?:web[-_ ]?fetch|fetch[-_ ]?web|webfetch|browser[-_ ]?fetch|fetch[-_ ]?url)$/i;
+export const CURSOR_TOOL_PRESENTATION_SPECS = [
+    {
+        normalizedName: "read",
+        nameAliases: ["read_file"],
+        displayLabel: "read",
+        visibility: { incompleteTitle: "Cursor read", fastLocalDiscovery: true },
+    },
+    {
+        normalizedName: "grep",
+        nameAliases: ["grep_search", "search"],
+        displayLabel: "grep",
+        visibility: { incompleteTitle: "Cursor grep", fastLocalDiscovery: true },
+    },
+    {
+        normalizedName: "glob",
+        nameAliases: ["file_search"],
+        displayLabel: "glob",
+        visibility: { incompleteTitle: "Cursor find", fastLocalDiscovery: true },
+    },
+    {
+        normalizedName: "ls",
+        nameAliases: ["list_dir"],
+        displayLabel: "ls",
+        visibility: { incompleteTitle: "Cursor ls", fastLocalDiscovery: true },
+    },
+    {
+        normalizedName: "shell",
+        nameAliases: ["run_terminal_cmd", "terminal", "bash"],
+        displayLabel: "shell",
+        visibility: {
+            incompleteTitle: "Cursor shell",
+            lifecycleTitle: "Cursor shell",
+            lifecycleEligible: true,
+        },
+        lifecycleLabelKind: "shell",
+    },
+    {
+        normalizedName: "edit",
+        nameAliases: [
+            "strreplace",
+            "str_replace",
+            "str-replace",
+            "edit_file",
+            "editfile",
+            "edit_notebook",
+            "editnotebook",
+            "notebook_edit",
+            "notebookedit",
+        ],
+        displayLabel: "Cursor edit",
+        visibility: {},
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayPath),
+    },
+    {
+        normalizedName: "write",
+        nameAliases: ["write_file", "writefile"],
+        displayLabel: "Cursor write",
+        visibility: {},
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayPath),
+    },
+    {
+        normalizedName: "delete",
+        displayLabel: "Cursor delete",
+        visibility: {},
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayPath),
+        activityReplay: {
+            buildActivityArgs: buildDeleteReplaySummaryArgs,
+            buildDetails: buildDeleteReplayDetailFields,
+        },
+    },
+    {
+        normalizedName: "readLints",
+        displayLabel: "Cursor diagnostics",
+        visibility: {},
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayReadLints),
+        activityReplay: {
+            buildActivityArgs: buildReadLintsReplaySummaryArgs,
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "updateTodos",
+        displayLabel: "Cursor todos",
+        visibility: { lifecycleEligible: true },
+        lifecycleLabelKind: "updateTodos",
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayTodoCount),
+        activityReplay: {
+            buildActivityArgs: ({ args, result }) => buildTodoReplaySummaryArgs(args, result),
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "createPlan",
+        displayLabel: "Cursor plan",
+        visibility: { lifecycleEligible: true },
+        lifecycleLabelKind: "createPlan",
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayPlan),
+        activityReplay: {
+            buildActivityArgs: buildCreatePlanReplaySummaryArgs,
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "task",
+        displayLabel: "Cursor subagent",
+        getActivityTitle: getCursorTaskActivityTitle,
+        visibility: { lifecycleEligible: true },
+        replayDisplay: { showCollapsedExpandHint: true },
+        lifecycleLabelKind: "task",
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayTask),
+        activityReplay: {
+            buildActivityArgs: buildTaskReplaySummaryArgs,
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "generateImage",
+        displayLabel: "Cursor image generation",
+        visibility: { lifecycleEligible: true },
+        lifecycleLabelKind: "generateImage",
+        replayCallSummary: withActivitySummaryFallback((args) => readCursorReplaySummaryString(args, "path") ?? readCursorReplaySummaryString(args, "prompt")),
+        generateImageReplay: {
+            buildActivityArgs: buildGenerateImageReplaySummaryArgs,
+            buildDetails: buildGenerateImageReplayDetailFields,
+        },
+    },
+    {
+        normalizedName: "mcp",
+        displayLabel: "Cursor MCP",
+        visibility: { lifecycleEligible: true },
+        lifecycleLabelKind: "mcp",
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayMcp),
+        activityReplay: {
+            buildActivityArgs: buildMcpReplaySummaryArgs,
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "semSearch",
+        displayLabel: "Cursor semantic search",
+        visibility: { lifecycleEligible: true },
+        lifecycleLabelKind: "semSearch",
+        replayCallSummary: withActivitySummaryFallback(formatReplaySemSearchQuery),
+        activityReplay: {
+            buildActivityArgs: buildSemSearchReplaySummaryArgs,
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "recordScreen",
+        displayLabel: "Cursor screen recording",
+        visibility: { lifecycleEligible: true },
+        lifecycleLabelKind: "recordScreen",
+        replayCallSummary: withActivitySummaryFallback(summarizeReplayRecordScreen),
+        activityReplay: {
+            buildActivityArgs: buildRecordScreenReplaySummaryArgs,
+            buildDetails: EMPTY_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "webSearch",
+        nameAliases: ["websearch", "web_search", "web-search"],
+        displayLabel: "Cursor web search",
+        visibility: { lifecycleEligible: true },
+        webKind: "webSearch",
+        webNamePatterns: [WEB_SEARCH_NAME_PATTERN],
+        lifecycleLabelKind: "webSearch",
+        replayCallSummary: withActivitySummaryFallback((args) => readCursorReplaySummaryString(args, "query")),
+        activityReplay: {
+            buildActivityArgs: buildWebSearchReplaySummaryArgs,
+            buildDetails: COLLAPSED_REPLAY_DETAIL_FIELDS,
+        },
+    },
+    {
+        normalizedName: "webFetch",
+        nameAliases: ["webfetch", "web_fetch", "web-fetch"],
+        displayLabel: "Cursor web fetch",
+        visibility: { lifecycleEligible: true },
+        webKind: "webFetch",
+        webNamePatterns: [WEB_FETCH_NAME_PATTERN],
+        lifecycleLabelKind: "webFetch",
+        replayCallSummary: withActivitySummaryFallback((args) => readCursorReplaySummaryString(args, "url")),
+        activityReplay: {
+            buildActivityArgs: buildWebFetchReplaySummaryArgs,
+            buildDetails: COLLAPSED_REPLAY_DETAIL_FIELDS,
+        },
+    },
+];
+function hasNeutralActivityTitle(spec) {
+    return Boolean(spec.activityReplay || spec.generateImageReplay || spec.normalizedName === "edit" || spec.normalizedName === "write");
+}
+const SPECS_BY_NORMALIZED_NAME = new Map(CURSOR_TOOL_PRESENTATION_SPECS.map((spec) => [spec.normalizedName, spec]));
+const SPECS_BY_NORMALIZED_KEY = new Map(CURSOR_TOOL_PRESENTATION_SPECS.map((spec) => [spec.normalizedName.toLowerCase(), spec]));
+const ALIAS_TO_NORMALIZED_NAME = new Map(CURSOR_TOOL_PRESENTATION_SPECS.flatMap((spec) => {
+    const aliases = "nameAliases" in spec ? spec.nameAliases : undefined;
+    return (aliases ?? []).map((alias) => [alias.toLowerCase(), spec.normalizedName]);
+}));
+const WEB_KIND_BY_PATTERN = CURSOR_TOOL_PRESENTATION_SPECS.flatMap((spec) => {
+    if (!("webKind" in spec) || !("webNamePatterns" in spec))
+        return [];
+    const { webKind, webNamePatterns } = spec;
+    if (!webKind || !webNamePatterns)
+        return [];
+    return webNamePatterns.map((pattern) => ({ pattern, webKind }));
+});
+export const CURSOR_KNOWN_NORMALIZED_TOOL_NAMES = CURSOR_REPLAY_SOURCE_TOOL_NAMES;
+export function getCursorToolPresentationSpec(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        return undefined;
+    return SPECS_BY_NORMALIZED_NAME.get(trimmed) ?? SPECS_BY_NORMALIZED_KEY.get(trimmed.toLowerCase());
+}
+export function normalizeCursorToolName(name) {
+    const normalized = name.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return "unknown";
+    const aliasTarget = ALIAS_TO_NORMALIZED_NAME.get(normalized.toLowerCase());
+    if (aliasTarget)
+        return aliasTarget;
+    const spec = getCursorToolPresentationSpec(normalized);
+    if (spec)
+        return spec.normalizedName;
+    return normalized;
+}
+export function classifyCursorWebToolKind(name) {
+    if (!name)
+        return undefined;
+    const normalized = name.replace(/\s+/g, " ").trim().toLowerCase();
+    for (const { pattern, webKind } of WEB_KIND_BY_PATTERN) {
+        if (pattern.test(normalized))
+            return webKind;
+    }
+    const spec = getCursorToolPresentationSpec(name);
+    return spec?.webKind;
+}
+export function isCursorReplayToolName(toolName) {
+    return toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME;
+}
+export function isExcludedFromCursorBridgeExposure(toolName) {
+    return toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME;
+}
+export function getCursorReplayPromptLabel(toolName) {
+    return toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME ? "Cursor activity" : toolName;
+}
+export function getCursorReplayActivityTitle(toolName) {
+    const spec = getCursorToolPresentationSpec(toolName);
+    if (!spec || !hasNeutralActivityTitle(spec))
+        return undefined;
+    return spec.getActivityTitle?.() ?? spec.displayLabel;
+}
+function buildCursorGenericActivityTitle(displayName) {
+    if (!displayName || displayName === "unknown")
+        return "Cursor tool";
+    return `Cursor ${truncateCursorDisplayLine(displayName, 120)}`;
+}
+/** Canonical activity title: registry label when known, otherwise neutral fallback. */
+export function getCursorToolActivityTitle(toolName) {
+    const normalized = normalizeCursorToolName(toolName);
+    const known = getCursorReplayActivityTitle(normalized);
+    if (known)
+        return known;
+    const label = toolName.trim() || normalized;
+    return buildCursorGenericActivityTitle(label);
+}
+function getCursorToolPresentationSpecByNormalizedKey(normalizedKey) {
+    return SPECS_BY_NORMALIZED_KEY.get(normalizedKey.toLowerCase());
+}
+export function getCursorToolVisibilityPolicy(normalizedKey) {
+    return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.visibility;
+}
+export function getCursorToolLifecycleLabelKind(normalizedKey) {
+    return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.lifecycleLabelKind;
+}
+export function getCursorToolActivityReplaySpec(normalizedKey) {
+    return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.activityReplay;
+}
+export function getCursorToolGenerateImageReplaySpec(normalizedKey) {
+    return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.generateImageReplay;
+}
+export function shouldShowCursorReplayCollapsedExpandHint(normalizedKey) {
+    if (!normalizedKey)
+        return false;
+    return getCursorToolPresentationSpecByNormalizedKey(normalizedKey)?.replayDisplay?.showCollapsedExpandHint === true;
+}
+export function getCursorReplayCallSummary(toolName, args) {
+    if (toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME) {
+        return readCursorReplaySummaryString(args, "activitySummary") ?? summarizeReplayGenericActivity(args);
+    }
+    return getCursorToolPresentationSpec(toolName)?.replayCallSummary?.(args);
+}

package/dist/cursor-tool-result-display-readers.js

@@ -0,0 +1,158 @@
+import { asRecord, getArray, getNumber, getRecord, getString, stringifyUnknown } from "./cursor-record-utils.js";
+import { summarizeCursorCompactConversationToolCall } from "./cursor-compact-tool-summary.js";
+import { scrubSensitiveText } from "./cursor-sensitive-text.js";
+import { firstNonEmptyLine, formatDisplayPath, truncateArg } from "./cursor-transcript-utils.js";
+export function getReadLintPaths(args, result, options) {
+    const explicitPaths = Array.isArray(args.paths)
+        ? args.paths.filter((entry) => typeof entry === "string")
+        : typeof args.path === "string"
+            ? [args.path]
+            : [];
+    const resultPaths = (getArray(asRecord(result.value), "fileDiagnostics") ?? [])
+        .map((file) => getString(asRecord(file), "path"))
+        .filter((entry) => Boolean(entry));
+    return [...new Set([...explicitPaths, ...resultPaths].map((entry) => formatDisplayPath(entry, options.cwd)))];
+}
+export function getReadLintDiagnostics(result, options) {
+    const value = asRecord(result.value);
+    const files = getArray(value, "fileDiagnostics") ?? [];
+    const lines = [];
+    for (const file of files) {
+        const fileRecord = asRecord(file);
+        const pathValue = getString(fileRecord, "path");
+        const path = pathValue ? formatDisplayPath(pathValue, options.cwd) : "unknown";
+        const diagnostics = getArray(fileRecord, "diagnostics") ?? [];
+        for (const diagnostic of diagnostics) {
+            const diagnosticRecord = asRecord(diagnostic);
+            const severity = getString(diagnosticRecord, "severity") ?? "diagnostic";
+            const message = getString(diagnosticRecord, "message") ?? "";
+            const source = getString(diagnosticRecord, "source");
+            lines.push(`${path}: ${severity}${source ? ` ${source}` : ""}: ${message}`);
+        }
+    }
+    return lines;
+}
+export function getTodoItems(args, result) {
+    const value = asRecord(result.value);
+    const rawTodos = getArray(value, "todos") ?? getArray(args, "todos") ?? [];
+    const todos = [];
+    for (const todo of rawTodos) {
+        const record = asRecord(todo);
+        const content = getString(record, "content");
+        if (!content)
+            continue;
+        const status = getString(record, "status");
+        todos.push(status ? { content, status } : { content });
+    }
+    return todos;
+}
+export function getTodoTotalCount(args, result, todos) {
+    return getNumber(asRecord(result.value), "totalCount") ?? getNumber(args, "totalCount") ?? todos.length;
+}
+function getNestedRecord(record, ...keys) {
+    let current = record;
+    for (const key of keys) {
+        current = getRecord(current, key);
+        if (!current)
+            return undefined;
+    }
+    return current;
+}
+function readConversationStepAssistantText(step) {
+    const record = asRecord(step);
+    const legacyText = getString(getRecord(record, "assistantMessage"), "text");
+    if (legacyText)
+        return legacyText;
+    if (getString(record, "type") !== "assistantMessage")
+        return undefined;
+    return getString(getRecord(record, "message"), "text");
+}
+export function collectTaskText(result, options = {}) {
+    const value = asRecord(result.value);
+    const success = getNestedRecord(value, "result", "success");
+    const command = getString(success, "command");
+    const stdout = getString(success, "stdout");
+    const interleavedOutput = getString(success, "interleavedOutput");
+    const conversationParts = (getArray(value, "conversationSteps") ?? [])
+        .map((step) => summarizeCursorCompactConversationToolCall(step, options) ?? readConversationStepAssistantText(step))
+        .filter((entry) => Boolean(entry));
+    const parts = [command ? `$ ${command}` : undefined, stdout || interleavedOutput, ...conversationParts].filter((part) => Boolean(part));
+    return parts.join("\n");
+}
+export function getGenerateImagePath(args, result) {
+    const value = asRecord(result.value);
+    return getString(value, "filePath") ?? getString(args, "filePath") ?? getString(args, "path");
+}
+export function getGenerateImageDisplayPath(args, result, options) {
+    const path = getGenerateImagePath(args, result);
+    return path ? formatDisplayPath(path, options.cwd) : undefined;
+}
+export function inferImageMimeType(path) {
+    const lower = path?.toLowerCase();
+    if (!lower)
+        return undefined;
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (lower.endsWith(".gif"))
+        return "image/gif";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    return undefined;
+}
+function getMcpContentText(entry) {
+    const record = asRecord(entry);
+    const directText = getString(record, "text");
+    if (directText)
+        return directText;
+    const nestedText = getRecord(record, "text");
+    return getString(nestedText, "text");
+}
+function describeNonTextMcpContent(entry) {
+    const record = asRecord(entry);
+    const type = getString(record, "type") ?? "content";
+    if (type === "image") {
+        const mimeType = getString(record, "mimeType") ?? getString(record, "mime") ?? getString(record, "mediaType");
+        return `[image${mimeType ? ` ${mimeType}` : ""} omitted]`;
+    }
+    if (type === "audio")
+        return "[audio omitted]";
+    if (type === "resource")
+        return "[resource omitted]";
+    return `[${type} omitted]`;
+}
+export function readMcpDisplayResult(result) {
+    if (result.status === "error") {
+        return { isToolError: false, text: "", nonTextSummary: "", body: "" };
+    }
+    const value = asRecord(result.value);
+    const isToolError = value?.isError === true;
+    const content = getArray(value, "content") ?? [];
+    const textParts = [];
+    const nonTextParts = [];
+    let preview;
+    for (const entry of content) {
+        const text = getMcpContentText(entry);
+        if (text) {
+            textParts.push(text);
+            const line = firstNonEmptyLine(text);
+            if (!preview && line)
+                preview = truncateArg(scrubSensitiveText(line), 120);
+            continue;
+        }
+        nonTextParts.push(describeNonTextMcpContent(entry));
+    }
+    if (!preview)
+        preview = nonTextParts[0];
+    const text = textParts.join("\n");
+    const nonTextSummary = nonTextParts.join("\n");
+    const body = text || nonTextSummary || scrubSensitiveText(stringifyUnknown(result.value), undefined);
+    return {
+        isToolError,
+        text,
+        nonTextSummary,
+        body: `${isToolError ? "[tool error]\n" : ""}${body}`.trim(),
+        ...(preview ? { preview } : {}),
+    };
+}

package/dist/cursor-tool-transcript.js

@@ -0,0 +1,32 @@
+import { asRecord, getString } from "./cursor-record-utils.js";
+import { normalizeCursorToolName } from "./cursor-tool-presentation-registry.js";
+import { buildCursorPiToolDisplayFromSpec, formatCursorToolTranscriptFromSpec, } from "./cursor-transcript-tool-specs.js";
+import { getToolArgs, getToolName, getToolResult, normalizeResult, } from "./cursor-transcript-utils.js";
+import { resolveTranscriptToolName } from "./cursor-web-tool-activity.js";
+function buildToolDisplayContext(toolCall, options = {}) {
+    const rawName = getToolName(toolCall);
+    const args = getToolArgs(toolCall);
+    return {
+        rawName,
+        name: resolveTranscriptToolName(rawName, args),
+        args,
+        result: normalizeResult(getToolResult(toolCall)),
+        options,
+    };
+}
+export function formatCursorToolTranscript(toolCall, options = {}) {
+    return formatCursorToolTranscriptFromSpec(buildToolDisplayContext(toolCall, options));
+}
+export function buildCursorPiToolDisplay(toolCall, options = {}) {
+    return buildCursorPiToolDisplayFromSpec(buildToolDisplayContext(toolCall, options));
+}
+export function getCursorCreatePlanText(toolCall) {
+    const name = normalizeCursorToolName(getToolName(toolCall));
+    if (name !== "createPlan")
+        return undefined;
+    const args = getToolArgs(toolCall);
+    const result = normalizeResult(getToolResult(toolCall));
+    const plan = getString(args, "plan") ?? getString(asRecord(result.value), "plan");
+    const trimmed = plan?.trim();
+    return trimmed || undefined;
+}

package/dist/cursor-tool-visibility.js

@@ -0,0 +1,28 @@
+import { getCursorReplayActivityTitle, getCursorToolVisibilityPolicy, normalizeCursorToolName as normalizeToolName, } from "./cursor-tool-presentation-registry.js";
+import { getToolArgs, getToolName } from "./cursor-transcript-utils.js";
+import { resolveTranscriptToolName } from "./cursor-web-tool-activity.js";
+export function getNormalizedCursorToolName(toolCall) {
+    return classifyCursorToolVisibility(toolCall).normalizedName;
+}
+export function classifyCursorToolVisibility(toolCall) {
+    const args = getToolArgs(toolCall);
+    const displayName = resolveTranscriptToolName(getToolName(toolCall), args);
+    const normalizedName = normalizeToolName(displayName);
+    const normalizedKey = normalizedName.toLowerCase();
+    const config = getCursorToolVisibilityPolicy(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) {
+    return classifyCursorToolVisibility(toolCall).fastLocalDiscovery;
+}