@elyracode/coding-agent 0.1.0 → 0.3.0

package/examples/extensions/session-name.ts

@@ -9,17 +9,17 @@
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("session-name", {
+export default function (elyra: ExtensionAPI) {
+	elyra.registerCommand("session-name", {
 		description: "Set or show session name (usage: /session-name [new name])",
 		handler: async (args, ctx) => {
 			const name = args.trim();
 
 			if (name) {
-				pi.setSessionName(name);
+				elyra.setSessionName(name);
 				ctx.ui.notify(`Session named: ${name}`, "info");
 			} else {
-				const current = pi.getSessionName();
+				const current = elyra.getSessionName();
 				ctx.ui.notify(current ? `Session: ${current}` : "No session name set", "info");
 			}
 		},

package/examples/extensions/shutdown-command.ts

@@ -2,26 +2,26 @@
  * Shutdown Command Extension
  *
  * Adds a /quit command that allows extensions to trigger clean shutdown.
- * Demonstrates how extensions can use ctx.shutdown() to exit pi cleanly.
+ * Demonstrates how extensions can use ctx.shutdown() to exit elyra cleanly.
  */
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 import { Type } from "typebox";
 
-export default function (pi: ExtensionAPI) {
-	// Register a /quit command that cleanly exits pi
-	pi.registerCommand("quit", {
-		description: "Exit pi cleanly",
+export default function (elyra: ExtensionAPI) {
+	// Register a /quit command that cleanly exits elyra
+	elyra.registerCommand("quit", {
+		description: "Exit elyra cleanly",
 		handler: async (_args, ctx) => {
 			ctx.shutdown();
 		},
 	});
 
 	// You can also create a tool that shuts down after completing work
-	pi.registerTool({
+	elyra.registerTool({
 		name: "finish_and_exit",
 		label: "Finish and Exit",
-		description: "Complete a task and exit pi",
+		description: "Complete a task and exit elyra",
 		parameters: Type.Object({}),
 		async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
 			// Do any final work here...
@@ -37,10 +37,10 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// You could also create a more complex tool with parameters
-	pi.registerTool({
+	elyra.registerTool({
 		name: "deploy_and_exit",
 		label: "Deploy and Exit",
-		description: "Deploy the application and exit pi",
+		description: "Deploy the application and exit elyra",
 		parameters: Type.Object({
 			environment: Type.String({ description: "Target environment (e.g., production, staging)" }),
 		}),
@@ -48,7 +48,7 @@ export default function (pi: ExtensionAPI) {
 			onUpdate?.({ content: [{ type: "text", text: `Deploying to ${params.environment}...` }], details: {} });
 
 			// Example deployment logic
-			// const result = await pi.exec("npm", ["run", "deploy", params.environment], { signal });
+			// const result = await elyra.exec("npm", ["run", "deploy", params.environment], { signal });
 
 			// On success, request graceful shutdown
 			onUpdate?.({ content: [{ type: "text", text: "Deployment complete, exiting..." }], details: {} });

package/examples/extensions/snake.ts

@@ -306,8 +306,8 @@ class SnakeComponent {
 
 const SNAKE_SAVE_TYPE = "snake-save";
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("snake", {
+export default function (elyra: ExtensionAPI) {
+	elyra.registerCommand("snake", {
 		description: "Play Snake!",
 
 		handler: async (_args, ctx) => {
@@ -333,7 +333,7 @@ export default function (pi: ExtensionAPI) {
 					() => done(undefined),
 					(state) => {
 						// Save or clear state
-						pi.appendEntry(SNAKE_SAVE_TYPE, state);
+						elyra.appendEntry(SNAKE_SAVE_TYPE, state);
 					},
 					savedState,
 				);

package/examples/extensions/space-invaders.ts

@@ -524,8 +524,8 @@ class SpaceInvadersComponent {
 
 const INVADERS_SAVE_TYPE = "space-invaders-save";
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("invaders", {
+export default function (elyra: ExtensionAPI) {
+	elyra.registerCommand("invaders", {
 		description: "Play Space Invaders!",
 
 		handler: async (_args, ctx) => {
@@ -550,7 +550,7 @@ export default function (pi: ExtensionAPI) {
 					tui,
 					() => done(undefined),
 					(state) => {
-						pi.appendEntry(INVADERS_SAVE_TYPE, state);
+						elyra.appendEntry(INVADERS_SAVE_TYPE, state);
 					},
 					savedState,
 				);

package/examples/extensions/ssh.ts

@@ -111,8 +111,8 @@ function createRemoteBashOps(remote: string, remoteCwd: string, localCwd: string
 	};
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.registerFlag("ssh", { description: "SSH remote: user@host or user@host:/path", type: "string" });
+export default function (elyra: ExtensionAPI) {
+	elyra.registerFlag("ssh", { description: "SSH remote: user@host or user@host:/path", type: "string" });
 
 	const localCwd = process.cwd();
 	const localRead = createReadTool(localCwd);
@@ -125,7 +125,7 @@ export default function (pi: ExtensionAPI) {
 
 	const getSsh = () => resolvedSsh;
 
-	pi.registerTool({
+	elyra.registerTool({
 		...localRead,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -139,7 +139,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerTool({
+	elyra.registerTool({
 		...localWrite,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -153,7 +153,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerTool({
+	elyra.registerTool({
 		...localEdit,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -167,7 +167,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerTool({
+	elyra.registerTool({
 		...localBash,
 		async execute(id, params, signal, onUpdate, _ctx) {
 			const ssh = getSsh();
@@ -181,9 +181,9 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.on("session_start", async (_event, ctx) => {
+	elyra.on("session_start", async (_event, ctx) => {
 		// Resolve SSH config now that CLI flags are available
-		const arg = pi.getFlag("ssh") as string | undefined;
+		const arg = elyra.getFlag("ssh") as string | undefined;
 		if (arg) {
 			if (arg.includes(":")) {
 				const [remote, path] = arg.split(":");
@@ -200,14 +200,14 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Handle user ! commands via SSH
-	pi.on("user_bash", (_event) => {
+	elyra.on("user_bash", (_event) => {
 		const ssh = getSsh();
 		if (!ssh) return; // No SSH, use local execution
 		return { operations: createRemoteBashOps(ssh.remote, ssh.remoteCwd, localCwd) };
 	});
 
 	// Replace local cwd with remote cwd in system prompt
-	pi.on("before_agent_start", async (event) => {
+	elyra.on("before_agent_start", async (event) => {
 		const ssh = getSsh();
 		if (ssh) {
 			const modified = event.systemPrompt.replace(

package/examples/extensions/status-line.ts

@@ -7,15 +7,15 @@
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	let turnCount = 0;
 
-	pi.on("session_start", async (_event, ctx) => {
+	elyra.on("session_start", async (_event, ctx) => {
 		const theme = ctx.ui.theme;
 		ctx.ui.setStatus("status-demo", theme.fg("dim", "Ready"));
 	});
 
-	pi.on("turn_start", async (_event, ctx) => {
+	elyra.on("turn_start", async (_event, ctx) => {
 		turnCount++;
 		const theme = ctx.ui.theme;
 		const spinner = theme.fg("accent", "●");
@@ -23,7 +23,7 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setStatus("status-demo", spinner + text);
 	});
 
-	pi.on("turn_end", async (_event, ctx) => {
+	elyra.on("turn_end", async (_event, ctx) => {
 		const theme = ctx.ui.theme;
 		const check = theme.fg("success", "✓");
 		const text = theme.fg("dim", ` Turn ${turnCount} complete`);

package/examples/extensions/structured-output.ts

@@ -60,6 +60,6 @@ const structuredOutputTool = defineTool({
 	},
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool(structuredOutputTool);
+export default function (elyra: ExtensionAPI) {
+	elyra.registerTool(structuredOutputTool);
 }

package/examples/extensions/subagent/index.ts

@@ -208,7 +208,7 @@ async function mapWithConcurrencyLimit<TIn, TOut>(
 }
 
 async function writePromptToTempFile(agentName: string, prompt: string): Promise<{ dir: string; filePath: string }> {
-	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pi-subagent-"));
+	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "elyra-subagent-"));
 	const safeName = agentName.replace(/[^\w.-]+/g, "_");
 	const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
 	await withFileMutationQueue(filePath, async () => {
@@ -428,8 +428,8 @@ const SubagentParams = Type.Object({
 	cwd: Type.Optional(Type.String({ description: "Working directory for the agent process (single mode)" })),
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool({
+export default function (elyra: ExtensionAPI) {
+	elyra.registerTool({
 		name: "subagent",
 		label: "Subagent",
 		description: [

package/examples/extensions/summarize.ts

@@ -142,8 +142,8 @@ const showSummaryUi = async (summary: string, ctx: ExtensionCommandContext) => {
 	});
 };
 
-export default function (pi: ExtensionAPI) {
-	pi.registerCommand("summarize", {
+export default function (elyra: ExtensionAPI) {
+	elyra.registerCommand("summarize", {
 		description: "Summarize the current conversation in a custom UI",
 		handler: async (_args, ctx) => {
 			const branch = ctx.sessionManager.getBranch();

package/examples/extensions/system-prompt-header.ts

@@ -5,13 +5,13 @@
  */
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
-	pi.on("agent_start", (_event, ctx) => {
+export default function (elyra: ExtensionAPI) {
+	elyra.on("agent_start", (_event, ctx) => {
 		const prompt = ctx.getSystemPrompt();
 		ctx.ui.setStatus("system-prompt", `System: ${prompt.length} chars`);
 	});
 
-	pi.on("session_shutdown", (_event, ctx) => {
+	elyra.on("session_shutdown", (_event, ctx) => {
 		ctx.ui.setStatus("system-prompt", undefined);
 	});
 }

package/examples/extensions/tic-tac-toe.ts

@@ -655,9 +655,9 @@ function getBoardDetails(): BoardDetails {
 	};
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+export default function (elyra: ExtensionAPI) {
+	elyra.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	elyra.on("session_tree", async (_event, ctx) => reconstructState(ctx));
 
 	// Sent once per game at end-of-game. The custom renderer paints the banner;
 	// `content` is a plain-text fallback for any non-TUI consumer and for the
@@ -671,7 +671,7 @@ export default function (pi: ExtensionAPI) {
 					: gameState.status === "draw"
 						? "Draw"
 						: "Game over";
-		pi.sendMessage({
+		elyra.sendMessage({
 			customType: GAME_OVER_MESSAGE_TYPE,
 			content: `Game over: ${label}.`,
 			display: true,
@@ -682,7 +682,7 @@ export default function (pi: ExtensionAPI) {
 	// -----------------------------------------------------------------------
 	// Custom message renderer for user move messages
 	// -----------------------------------------------------------------------
-	pi.registerMessageRenderer(MOVE_MESSAGE_TYPE, (message, { expanded }, theme) => {
+	elyra.registerMessageRenderer(MOVE_MESSAGE_TYPE, (message, { expanded }, theme) => {
 		const details = message.details as BoardDetails | undefined;
 		const turnLabel =
 			details?.currentTurn === "O"
@@ -695,7 +695,7 @@ export default function (pi: ExtensionAPI) {
 	// -----------------------------------------------------------------------
 	// Custom message renderer for game-over messages
 	// -----------------------------------------------------------------------
-	pi.registerMessageRenderer(GAME_OVER_MESSAGE_TYPE, (message, _options, theme) => {
+	elyra.registerMessageRenderer(GAME_OVER_MESSAGE_TYPE, (message, _options, theme) => {
 		const details = message.details as BoardDetails | undefined;
 		const status = (details?.status ?? "draw") as GameStatus;
 		return new GameOverMessageComponent(status, details, theme);
@@ -704,7 +704,7 @@ export default function (pi: ExtensionAPI) {
 	// -----------------------------------------------------------------------
 	// before_agent_start - inject game instructions each turn
 	// -----------------------------------------------------------------------
-	pi.on("before_agent_start", async (event) => {
+	elyra.on("before_agent_start", async (event) => {
 		if (!gameActive) return undefined;
 
 		const instructions = `
@@ -775,7 +775,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 	// -----------------------------------------------------------------------
 	// /tic-tac-toe command
 	// -----------------------------------------------------------------------
-	pi.registerCommand("tic-tac-toe", {
+	elyra.registerCommand("tic-tac-toe", {
 		description: "Play tic-tac-toe against the agent",
 
 		handler: async (_args, ctx) => {
@@ -789,7 +789,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 				gameState = createInitialState();
 			}
 			gameActive = true;
-			pi.setSessionName("Tic-Tac-Toe");
+			elyra.setSessionName("Tic-Tac-Toe");
 
 			await ctx.ui.custom<void>((tui, _theme, _kb, done) => {
 				component = new TicTacToeComponent(
@@ -806,7 +806,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 							gameState.currentTurn = gameState.agentMark;
 						}
 						component?.updateState(gameState);
-						pi.appendEntry(SAVE_TYPE, getBoardDetails());
+						elyra.appendEntry(SAVE_TYPE, getBoardDetails());
 
 						if (gameState.status === "playing") {
 							// IMPORTANT: user play does NOT touch the agent cursor.
@@ -816,7 +816,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 								gameState.agentCursorRow,
 								gameState.agentCursorCol,
 							);
-							pi.sendMessage(
+							elyra.sendMessage(
 								{
 									customType: MOVE_MESSAGE_TYPE,
 									content:
@@ -856,7 +856,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 		play: 0,
 	};
 
-	pi.registerTool({
+	elyra.registerTool({
 		name: "tic_tac_toe",
 		label: "Tic-Tac-Toe",
 		description:
@@ -910,7 +910,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 						// Do NOT reset the cursor on failure. The agent can retry
 						// from the cursor's current position.
 						component?.updateState(gameState);
-						pi.appendEntry(SAVE_TYPE, getBoardDetails());
+						elyra.appendEntry(SAVE_TYPE, getBoardDetails());
 						throw new TicTacToeError(
 							`Cell (${r},${c}) is already ${gameState.board[r][c]}. Your cursor is still at (${r},${c}). Move to an empty cell and retry play.`,
 						);
@@ -939,7 +939,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 			}
 
 			component?.updateState(gameState);
-			pi.appendEntry(SAVE_TYPE, getBoardDetails());
+			elyra.appendEntry(SAVE_TYPE, getBoardDetails());
 
 			return {
 				content: [{ type: "text", text: result }],
@@ -969,7 +969,7 @@ Decide the target cell first, then dump every action for the turn in one go.
 	// -----------------------------------------------------------------------
 	// tic_tac_toe_see_board tool - inspect board + agent cursor.
 	// -----------------------------------------------------------------------
-	pi.registerTool({
+	elyra.registerTool({
 		name: "tic_tac_toe_see_board",
 		label: "See Board",
 		description:

package/examples/extensions/timed-confirm.ts

@@ -9,9 +9,9 @@
 
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	// Simple approach: use timeout option (recommended)
-	pi.registerCommand("timed", {
+	elyra.registerCommand("timed", {
 		description: "Show a timed confirmation dialog (auto-cancels in 5s with countdown)",
 		handler: async (_args, ctx) => {
 			const confirmed = await ctx.ui.confirm(
@@ -28,7 +28,7 @@ export default function (pi: ExtensionAPI) {
 		},
 	});
 
-	pi.registerCommand("timed-select", {
+	elyra.registerCommand("timed-select", {
 		description: "Show a timed select dialog (auto-cancels in 10s with countdown)",
 		handler: async (_args, ctx) => {
 			const choice = await ctx.ui.select("Pick an option", ["Option A", "Option B", "Option C"], { timeout: 10000 });
@@ -42,7 +42,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Manual approach: use AbortSignal for more control
-	pi.registerCommand("timed-signal", {
+	elyra.registerCommand("timed-signal", {
 		description: "Show a timed confirm using AbortSignal (manual approach)",
 		handler: async (_args, ctx) => {
 			const controller = new AbortController();

package/examples/extensions/titlebar-spinner.ts

@@ -13,13 +13,13 @@ import type { ExtensionAPI, ExtensionContext } from "@elyracode/coding-agent";
 
 const BRAILLE_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
-function getBaseTitle(pi: ExtensionAPI): string {
+function getBaseTitle(elyra: ExtensionAPI): string {
 	const cwd = path.basename(process.cwd());
-	const session = pi.getSessionName();
+	const session = elyra.getSessionName();
 	return session ? `π - ${session} - ${cwd}` : `π - ${cwd}`;
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	let timer: ReturnType<typeof setInterval> | null = null;
 	let frameIndex = 0;
 
@@ -29,7 +29,7 @@ export default function (pi: ExtensionAPI) {
 			timer = null;
 		}
 		frameIndex = 0;
-		ctx.ui.setTitle(getBaseTitle(pi));
+		ctx.ui.setTitle(getBaseTitle(elyra));
 	}
 
 	function startAnimation(ctx: ExtensionContext) {
@@ -37,22 +37,22 @@ export default function (pi: ExtensionAPI) {
 		timer = setInterval(() => {
 			const frame = BRAILLE_FRAMES[frameIndex % BRAILLE_FRAMES.length];
 			const cwd = path.basename(process.cwd());
-			const session = pi.getSessionName();
+			const session = elyra.getSessionName();
 			const title = session ? `${frame} π - ${session} - ${cwd}` : `${frame} π - ${cwd}`;
 			ctx.ui.setTitle(title);
 			frameIndex++;
 		}, 80);
 	}
 
-	pi.on("agent_start", async (_event, ctx) => {
+	elyra.on("agent_start", async (_event, ctx) => {
 		startAnimation(ctx);
 	});
 
-	pi.on("agent_end", async (_event, ctx) => {
+	elyra.on("agent_end", async (_event, ctx) => {
 		stopAnimation(ctx);
 	});
 
-	pi.on("session_shutdown", async (_event, ctx) => {
+	elyra.on("session_shutdown", async (_event, ctx) => {
 		stopAnimation(ctx);
 	});
 }

package/examples/extensions/todo.ts

@@ -102,7 +102,7 @@ class TodoListComponent {
 	}
 }
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	// In-memory state (reconstructed from session on load)
 	let todos: Todo[] = [];
 	let nextId = 1;
@@ -129,11 +129,11 @@ export default function (pi: ExtensionAPI) {
 	};
 
 	// Reconstruct state on session events
-	pi.on("session_start", async (_event, ctx) => reconstructState(ctx));
-	pi.on("session_tree", async (_event, ctx) => reconstructState(ctx));
+	elyra.on("session_start", async (_event, ctx) => reconstructState(ctx));
+	elyra.on("session_tree", async (_event, ctx) => reconstructState(ctx));
 
 	// Register the todo tool for the LLM
-	pi.registerTool({
+	elyra.registerTool({
 		name: "todo",
 		label: "Todo",
 		description: "Manage a todo list. Actions: list, add (text), toggle (id), clear",
@@ -281,7 +281,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Register the /todos command for users
-	pi.registerCommand("todos", {
+	elyra.registerCommand("todos", {
 		description: "Show all todos on the current branch",
 		handler: async (_args, ctx) => {
 			if (!ctx.hasUI) {

package/examples/extensions/tool-override.ts

@@ -65,8 +65,8 @@ const readSchema = Type.Object({
 	limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
 });
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool({
+export default function (elyra: ExtensionAPI) {
+	elyra.registerTool({
 		name: "read", // Same name as built-in - this will override it
 		label: "read (audited)",
 		description:
@@ -129,7 +129,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Also register a command to view the access log
-	pi.registerCommand("read-log", {
+	elyra.registerCommand("read-log", {
 		description: "View the file access log",
 		handler: async (_args, ctx) => {
 			try {

package/examples/extensions/tools.ts

@@ -18,26 +18,26 @@ interface ToolsState {
 	enabledTools: string[];
 }
 
-export default function toolsExtension(pi: ExtensionAPI) {
+export default function toolsExtension(elyra: ExtensionAPI) {
 	// Track enabled tools
 	let enabledTools: Set<string> = new Set();
 	let allTools: ToolInfo[] = [];
 
 	// Persist current state
 	function persistState() {
-		pi.appendEntry<ToolsState>("tools-config", {
+		elyra.appendEntry<ToolsState>("tools-config", {
 			enabledTools: Array.from(enabledTools),
 		});
 	}
 
 	// Apply current tool selection
 	function applyTools() {
-		pi.setActiveTools(Array.from(enabledTools));
+		elyra.setActiveTools(Array.from(enabledTools));
 	}
 
 	// Find the last tools-config entry in the current branch
 	function restoreFromBranch(ctx: ExtensionContext) {
-		allTools = pi.getAllTools();
+		allTools = elyra.getAllTools();
 
 		// Get entries in current branch only
 		const branchEntries = ctx.sessionManager.getBranch();
@@ -59,16 +59,16 @@ export default function toolsExtension(pi: ExtensionAPI) {
 			applyTools();
 		} else {
 			// No saved state - sync with currently active tools
-			enabledTools = new Set(pi.getActiveTools());
+			enabledTools = new Set(elyra.getActiveTools());
 		}
 	}
 
 	// Register /tools command
-	pi.registerCommand("tools", {
+	elyra.registerCommand("tools", {
 		description: "Enable/disable tools",
 		handler: async (_args, ctx) => {
 			// Refresh tool list
-			allTools = pi.getAllTools();
+			allTools = elyra.getAllTools();
 
 			await ctx.ui.custom((tui, theme, _kb, done) => {
 				// Build settings items for each tool
@@ -130,12 +130,12 @@ export default function toolsExtension(pi: ExtensionAPI) {
 	});
 
 	// Restore state on session start
-	pi.on("session_start", async (_event, ctx) => {
+	elyra.on("session_start", async (_event, ctx) => {
 		restoreFromBranch(ctx);
 	});
 
 	// Restore state when navigating the session tree
-	pi.on("session_tree", async (_event, ctx) => {
+	elyra.on("session_tree", async (_event, ctx) => {
 		restoreFromBranch(ctx);
 	});
 }

package/examples/extensions/trigger-compact.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@elyracode/coding-agent";
 
 const COMPACT_THRESHOLD_TOKENS = 100_000;
 
-export default function (pi: ExtensionAPI) {
+export default function (elyra: ExtensionAPI) {
 	let previousTokens: number | null | undefined;
 
 	const triggerCompaction = (ctx: ExtensionContext, customInstructions?: string) => {
@@ -24,7 +24,7 @@ export default function (pi: ExtensionAPI) {
 		});
 	};
 
-	pi.on("turn_end", (_event, ctx) => {
+	elyra.on("turn_end", (_event, ctx) => {
 		const usage = ctx.getContextUsage();
 		const currentTokens = usage?.tokens ?? null;
 		if (currentTokens === null) {
@@ -40,7 +40,7 @@ export default function (pi: ExtensionAPI) {
 		triggerCompaction(ctx);
 	});
 
-	pi.registerCommand("trigger-compact", {
+	elyra.registerCommand("trigger-compact", {
 		description: "Trigger compaction immediately",
 		handler: async (args, ctx) => {
 			const instructions = args.trim() || undefined;

package/examples/extensions/truncated-tool.ts

@@ -45,8 +45,8 @@ interface RgDetails {
 	fullOutputPath?: string;
 }
 
-export default function (pi: ExtensionAPI) {
-	pi.registerTool({
+export default function (elyra: ExtensionAPI) {
+	elyra.registerTool({
 		name: "rg",
 		label: "ripgrep",
 		// Document the truncation limits in the tool description so the LLM knows
@@ -109,7 +109,7 @@ export default function (pi: ExtensionAPI) {
 
 			if (truncation.truncated) {
 				// Save full output to a temp file so LLM can access it if needed
-				const tempDir = await mkdtemp(join(tmpdir(), "pi-rg-"));
+				const tempDir = await mkdtemp(join(tmpdir(), "elyra-rg-"));
 				const tempFile = join(tempDir, "output.txt");
 				await withFileMutationQueue(tempFile, async () => {
 					await writeFile(tempFile, output, "utf8");

package/examples/extensions/widget-placement.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@elyracode/coding-agent";
 
-export default function widgetPlacementExtension(pi: ExtensionAPI) {
-	pi.on("session_start", (_event, ctx) => {
+export default function widgetPlacementExtension(elyra: ExtensionAPI) {
+	elyra.on("session_start", (_event, ctx) => {
 		if (!ctx.hasUI) return;
 		ctx.ui.setWidget("widget-above", ["Above editor widget"]);
 		ctx.ui.setWidget("widget-below", ["Below editor widget"], { placement: "belowEditor" });