pi-cursor-sdk 0.1.14 → 0.1.16

package/src/cursor-session-scope.ts

@@ -0,0 +1,65 @@
+import type { ExtensionHandler, SessionStartEvent } from "@earendil-works/pi-coding-agent";
+
+interface CursorSessionScopeExtensionApi {
+	on(event: "session_start", handler: ExtensionHandler<SessionStartEvent>): void;
+}
+
+const ANONYMOUS_SESSION_SCOPE_KEY = "__anonymous__";
+
+type CursorSessionScopeChangeHandler = (previousScopeKey: string) => void;
+
+const state = {
+	sessionCwd: process.cwd(),
+	sessionFile: undefined as string | undefined,
+};
+
+let scopeChangeHandler: CursorSessionScopeChangeHandler | undefined;
+
+/**
+ * Pi session file when known; used to scope reused Cursor SDK agents to one pi session.
+ */
+export function getCursorSessionFile(): string | undefined {
+	return state.sessionFile;
+}
+
+/**
+ * Stable scope key for session-agent pooling. Falls back to a process-local anonymous key
+ * before the first session_start (tests and early startup).
+ */
+export function getCursorSessionScopeKey(): string {
+	return state.sessionFile ?? ANONYMOUS_SESSION_SCOPE_KEY;
+}
+
+export function getCursorSessionCwdFromScope(): string {
+	return state.sessionCwd;
+}
+
+function setCursorSessionScope(cwd: string, sessionFile: string | undefined): void {
+	state.sessionCwd = cwd;
+	state.sessionFile = sessionFile;
+}
+
+function resetCursorSessionScope(): void {
+	state.sessionCwd = process.cwd();
+	state.sessionFile = undefined;
+}
+
+export function onCursorSessionScopeKeyChange(handler: CursorSessionScopeChangeHandler): void {
+	scopeChangeHandler = handler;
+}
+
+export function registerCursorSessionScope(pi: CursorSessionScopeExtensionApi): void {
+	pi.on("session_start", (_event, ctx) => {
+		const previousScopeKey = getCursorSessionScopeKey();
+		setCursorSessionScope(ctx.cwd, ctx.sessionManager?.getSessionFile?.() ?? undefined);
+		if (previousScopeKey !== getCursorSessionScopeKey()) {
+			scopeChangeHandler?.(previousScopeKey);
+		}
+	});
+}
+
+export const __testUtils = {
+	ANONYMOUS_SESSION_SCOPE_KEY,
+	set: setCursorSessionScope,
+	reset: resetCursorSessionScope,
+};

package/src/cursor-state.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, SessionStartEvent } from "@earendil-works/pi-coding-agent";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getCursorModelMetadata } from "./model-discovery.js";
 
@@ -17,6 +17,26 @@ interface CursorGlobalConfig {
 	fastDefaults?: Record<string, boolean>;
 }
 
+type CursorFastControlsModel =
+	| Pick<NonNullable<ExtensionContext["model"]>, "id" | "provider" | "api">
+	| undefined;
+
+type CursorFastControlsContext = {
+	model: CursorFastControlsModel;
+	ui: Pick<ExtensionContext["ui"], "notify" | "setStatus">;
+	sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch">;
+};
+
+interface CursorFastControlsExtensionApi extends Pick<ExtensionAPI, "appendEntry" | "getFlag" | "registerFlag"> {
+	registerCommand(name: string, options: {
+		description?: string;
+		handler: (args: string, ctx: CursorFastControlsContext) => Promise<void> | void;
+	}): void;
+	on(event: "session_start", handler: (event: SessionStartEvent, ctx: CursorFastControlsContext) => Promise<void> | void): void;
+	on(event: "model_select", handler: (event: { model: ExtensionContext["model"] }, ctx: CursorFastControlsContext) => Promise<void> | void): void;
+	on(event: "turn_start", handler: (event: unknown, ctx: CursorFastControlsContext) => Promise<void> | void): void;
+}
+
 const sessionFastPreferences = new Map<string, boolean>();
 let globalFastPreferences = new Map<string, boolean>();
 let cliForceFast = false;
@@ -56,7 +76,7 @@ function saveGlobalFastPreferences(): void {
 	writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
 }
 
-function restoreSessionFastPreferences(ctx: ExtensionContext): void {
+function restoreSessionFastPreferences(ctx: { sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch"> }): void {
 	sessionFastPreferences.clear();
 	for (const entry of ctx.sessionManager.getBranch()) {
 		if (entry.type !== "custom" || entry.customType !== FAST_ENTRY_TYPE) continue;
@@ -74,23 +94,27 @@ function getEffectiveFast(baseModelId: string, modelId: string): boolean | undef
 	return sessionFastPreferences.get(baseModelId) ?? globalFastPreferences.get(baseModelId) ?? metadata.defaultFast;
 }
 
-function updateCursorStatus(ctx: ExtensionContext, model = ctx.model): void {
-	if (model?.provider !== CURSOR_PROVIDER) {
+function isCursorModel(model: CursorFastControlsModel): boolean {
+	return model?.provider === CURSOR_PROVIDER || model?.api === "cursor-sdk";
+}
+
+function updateCursorStatus(ctx: { model: CursorFastControlsModel; ui: Pick<ExtensionContext["ui"], "setStatus"> }, model = ctx.model): void {
+	if (!model || !isCursorModel(model)) {
 		ctx.ui.setStatus("cursor", undefined);
 		return;
 	}
 	const metadata = getCursorModelMetadata(model.id);
-	if (!metadata) {
+	if (!metadata?.supportsFast) {
 		ctx.ui.setStatus("cursor", undefined);
 		return;
 	}
 	const fast = getEffectiveFast(metadata.baseModelId, model.id);
-	ctx.ui.setStatus("cursor", fast ? "cursor fast" : undefined);
+	ctx.ui.setStatus("cursor", fast === true ? "cursor fast" : undefined);
 }
 
-function getCurrentCursorMetadata(ctx: ExtensionContext) {
+function getCurrentCursorMetadata(ctx: { model: CursorFastControlsModel }) {
 	const model = ctx.model;
-	if (model?.provider !== CURSOR_PROVIDER) return undefined;
+	if (!model || !isCursorModel(model)) return undefined;
 	return getCursorModelMetadata(model.id);
 }
 
@@ -102,7 +126,7 @@ function restoreMapValue(map: Map<string, boolean>, key: string, previous: boole
 	}
 }
 
-function persistFastPreference(pi: ExtensionAPI, baseModelId: string, fast: boolean): void {
+function persistFastPreference(pi: Pick<ExtensionAPI, "appendEntry">, baseModelId: string, fast: boolean): void {
 	const previousSession = sessionFastPreferences.get(baseModelId);
 	const previousGlobal = globalFastPreferences.get(baseModelId);
 	let savedGlobal = false;
@@ -132,7 +156,7 @@ export function getEffectiveFastForModelId(modelId: string): boolean | undefined
 	return getEffectiveFast(metadata.baseModelId, modelId);
 }
 
-export function registerCursorFastControls(pi: ExtensionAPI): void {
+export function registerCursorFastControls(pi: CursorFastControlsExtensionApi): void {
 	pi.registerFlag("cursor-fast", {
 		description: "Force Cursor fast mode for this run when the selected Cursor model supports it",
 		type: "boolean",
@@ -188,6 +212,10 @@ export function registerCursorFastControls(pi: ExtensionAPI): void {
 	pi.on("model_select", async (event, ctx) => {
 		updateCursorStatus(ctx, event.model);
 	});
+
+	pi.on("turn_start", async (_event, ctx) => {
+		updateCursorStatus(ctx);
+	});
 }
 
 export const __testUtils = {

package/src/cursor-tool-names.ts

@@ -0,0 +1,67 @@
+export const CURSOR_REPLAY_ACTIVITY_TOOL_NAME = "cursor";
+
+export const CURSOR_REPLAY_LEGACY_TOOL_NAMES = [
+	"cursor_edit",
+	"cursor_write",
+	"cursor_read_lints",
+	"cursor_delete",
+	"cursor_update_todos",
+	"cursor_task",
+	"cursor_create_plan",
+	"cursor_generate_image",
+	"cursor_mcp",
+] as const;
+
+export type CursorReplayLegacyToolName = (typeof CURSOR_REPLAY_LEGACY_TOOL_NAMES)[number];
+export type CursorReplayToolName = typeof CURSOR_REPLAY_ACTIVITY_TOOL_NAME | CursorReplayLegacyToolName;
+
+const CURSOR_REPLAY_SOURCE_TOOL_NAMES = {
+	cursor_edit: "edit",
+	cursor_write: "write",
+	cursor_read_lints: "readLints",
+	cursor_delete: "delete",
+	cursor_update_todos: "updateTodos",
+	cursor_task: "task",
+	cursor_create_plan: "createPlan",
+	cursor_generate_image: "generateImage",
+	cursor_mcp: "MCP",
+} as const satisfies Record<CursorReplayLegacyToolName, string>;
+
+const CURSOR_REPLAY_PROMPT_LABELS = {
+	cursor_edit: "Cursor edit",
+	cursor_write: "Cursor write",
+	cursor_read_lints: "Cursor diagnostics",
+	cursor_delete: "Cursor delete",
+	cursor_update_todos: "Cursor todos",
+	cursor_task: "Cursor task",
+	cursor_create_plan: "Cursor plan",
+	cursor_generate_image: "Cursor image generation",
+	cursor_mcp: "Cursor MCP",
+} as const satisfies Record<CursorReplayLegacyToolName, string>;
+
+export function isCursorReplayLegacyToolName(toolName: string): toolName is CursorReplayLegacyToolName {
+	return CURSOR_REPLAY_LEGACY_TOOL_NAMES.some((legacyToolName) => legacyToolName === toolName);
+}
+
+export function isCursorReplayToolName(toolName: string): toolName is CursorReplayToolName {
+	return toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME || isCursorReplayLegacyToolName(toolName);
+}
+
+export function isExcludedFromCursorBridgeExposure(toolName: string): boolean {
+	return isCursorReplayLegacyToolName(toolName) || toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME;
+}
+
+export function getCursorReplaySourceToolName(toolName: CursorReplayLegacyToolName): string {
+	return CURSOR_REPLAY_SOURCE_TOOL_NAMES[toolName];
+}
+
+export function getCursorReplayPromptLabel(toolName: string): string {
+	if (toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME) return "Cursor activity";
+	if (isCursorReplayLegacyToolName(toolName)) return CURSOR_REPLAY_PROMPT_LABELS[toolName];
+	return toolName;
+}
+
+export function getCursorReplayDisplayLabel(toolName: CursorReplayToolName): string {
+	if (toolName === CURSOR_REPLAY_ACTIVITY_TOOL_NAME) return "Cursor activity";
+	return CURSOR_REPLAY_PROMPT_LABELS[toolName];
+}