my-pi 0.0.13 → 0.1.1

package/src/extensions/extensions.ts

@@ -1,4 +1,7 @@
-import type { ExtensionAPI } from '@mariozechner/pi-coding-agent';
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+} from '@mariozechner/pi-coding-agent';
 import {
 	Container,
 	SettingsList,
@@ -136,6 +139,113 @@ export function create_extensions_extension(
 		options.force_disabled,
 	);
 
+	async function show_manager(
+		ctx: ExtensionCommandContext,
+	): Promise<boolean> {
+		if (!ctx.hasUI) return false;
+
+		const states = resolve_builtin_extension_states(force_disabled);
+		const initial_enabled = new Set(
+			states
+				.filter((state) => state.saved_enabled)
+				.map((state) => state.key),
+		);
+		const current_enabled = new Set(initial_enabled);
+
+		await ctx.ui.custom((tui, theme, _kb, done) => {
+			const items = states.map(to_setting_item);
+			const container = new Container();
+
+			container.addChild({
+				render: () => {
+					const saved_enabled = current_enabled.size;
+					const saved_disabled = states.length - saved_enabled;
+					const enabled_now = [...current_enabled].filter(
+						(key) => !force_disabled.has(key as BuiltinExtensionKey),
+					).length;
+					const disabled_now = states.length - enabled_now;
+					return [
+						theme.fg('accent', theme.bold('Built-in extensions')),
+						theme.fg(
+							'muted',
+							`${saved_enabled} saved enabled • ${saved_disabled} saved disabled • ${enabled_now} enabled now • ${disabled_now} disabled now`,
+						),
+						'',
+					];
+				},
+				invalidate: () => {},
+			});
+
+			const settings_list = new SettingsList(
+				items,
+				Math.min(Math.max(items.length + 4, 8), 16),
+				{
+					cursor: theme.fg('accent', '›'),
+					label: (text, selected) =>
+						selected ? theme.fg('accent', text) : text,
+					value: (text, selected) => {
+						const color = text === ENABLED ? 'success' : 'dim';
+						const rendered = theme.fg(color, text);
+						return selected
+							? theme.bold(theme.fg('accent', rendered))
+							: rendered;
+					},
+					description: (text) => theme.fg('muted', text),
+					hint: (text) => theme.fg('dim', text),
+				},
+				(id, new_value) => {
+					const key = id as BuiltinExtensionKey;
+					const enabled = new_value === ENABLED;
+					if (enabled) {
+						current_enabled.add(key);
+					} else {
+						current_enabled.delete(key);
+					}
+					save_extension_enabled(key, enabled);
+				},
+				() => done(undefined),
+				{ enableSearch: true },
+			);
+
+			container.addChild(settings_list);
+			container.addChild(
+				new Text(
+					theme.fg(
+						'dim',
+						'esc close • search filters • changes save immediately • CLI --no-* flags still win in this process',
+					),
+					0,
+					1,
+				),
+			);
+
+			return {
+				render(width: number) {
+					return container.render(width);
+				},
+				invalidate() {
+					container.invalidate();
+				},
+				handleInput(data: string) {
+					settings_list.handleInput(data);
+					tui.requestRender();
+				},
+			};
+		});
+
+		if (!sets_equal(initial_enabled, current_enabled)) {
+			ctx.ui.notify(
+				force_disabled.size > 0
+					? 'Reloading to apply updated built-in extensions. CLI --no-* flags still force-disable some extensions in this process.'
+					: 'Reloading to apply updated built-in extensions...',
+				'info',
+			);
+			await ctx.reload();
+		}
+
+		return true;
+	}
+
 	return async function extensions(pi: ExtensionAPI) {
 		const subs = ['list', 'enable', 'disable', 'toggle', 'search'];
 
@@ -169,113 +279,8 @@ export function create_extensions_extension(
 			handler: async (args, ctx) => {
 				const trimmed = args.trim();
 
-				if (!trimmed && ctx.hasUI) {
-					const states =
-						resolve_builtin_extension_states(force_disabled);
-					const initial_enabled = new Set(
-						states
-							.filter((state) => state.saved_enabled)
-							.map((state) => state.key),
-					);
-					const current_enabled = new Set(initial_enabled);
-
-					await ctx.ui.custom((tui, theme, _kb, done) => {
-						const items = states.map(to_setting_item);
-						const container = new Container();
-
-						container.addChild({
-							render: () => {
-								const saved_enabled = current_enabled.size;
-								const saved_disabled = states.length - saved_enabled;
-								const enabled_now = [...current_enabled].filter(
-									(key) =>
-										!force_disabled.has(key as BuiltinExtensionKey),
-								).length;
-								const disabled_now = states.length - enabled_now;
-								return [
-									theme.fg(
-										'accent',
-										theme.bold('Built-in extensions'),
-									),
-									theme.fg(
-										'muted',
-										`${saved_enabled} saved enabled • ${saved_disabled} saved disabled • ${enabled_now} enabled now • ${disabled_now} disabled now`,
-									),
-									'',
-								];
-							},
-							invalidate: () => {},
-						});
-
-						const settings_list = new SettingsList(
-							items,
-							Math.min(Math.max(items.length + 4, 8), 16),
-							{
-								cursor: theme.fg('accent', '›'),
-								label: (text, selected) =>
-									selected ? theme.fg('accent', text) : text,
-								value: (text, selected) => {
-									const color = text === ENABLED ? 'success' : 'dim';
-									const rendered = theme.fg(color, text);
-									return selected
-										? theme.bold(theme.fg('accent', rendered))
-										: rendered;
-								},
-								description: (text) => theme.fg('muted', text),
-								hint: (text) => theme.fg('dim', text),
-							},
-							(id, new_value) => {
-								const key = id as BuiltinExtensionKey;
-								const enabled = new_value === ENABLED;
-								if (enabled) {
-									current_enabled.add(key);
-								} else {
-									current_enabled.delete(key);
-								}
-								save_extension_enabled(key, enabled);
-							},
-							() => done(undefined),
-							{ enableSearch: true },
-						);
-
-						container.addChild(settings_list);
-						container.addChild(
-							new Text(
-								theme.fg(
-									'dim',
-									'esc close • search filters • changes save immediately • CLI --no-* flags still win in this process',
-								),
-								0,
-								1,
-							),
-						);
-
-						return {
-							render(width: number) {
-								return container.render(width);
-							},
-							invalidate() {
-								container.invalidate();
-							},
-							handleInput(data: string) {
-								settings_list.handleInput(data);
-								tui.requestRender();
-							},
-						};
-					});
-
-					if (!sets_equal(initial_enabled, current_enabled)) {
-						ctx.ui.notify(
-							force_disabled.size > 0
-								? 'Reloading to apply updated built-in extensions. CLI --no-* flags still force-disable some extensions in this process.'
-								: 'Reloading to apply updated built-in extensions...',
-							'info',
-						);
-						await ctx.reload();
-						return;
-					}
-
-					return;
+				if (!trimmed) {
+					if (await show_manager(ctx)) return;
 				}
 
 				const [sub, ...rest] = (trimmed || 'list').split(/\s+/);
@@ -296,6 +301,7 @@ export function create_extensions_extension(
 					case 'disable':
 					case 'toggle': {
 						if (!arg) {
+							if (await show_manager(ctx)) return;
 							ctx.ui.notify(
 								`Usage: /extensions ${sub} <key>`,
 								'warning',

package/src/extensions/handoff.ts

@@ -1,87 +1,173 @@
-// Handoff extension — extract session context for a new session
-// Inspired by jayshah5696/pi-agent-extensions
+// Handoff extension — generate a focused prompt for a new session
 
-import type { ExtensionAPI } from '@mariozechner/pi-coding-agent';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { complete, type Message } from '@mariozechner/pi-ai';
+import type {
+	ExtensionAPI,
+	SessionEntry,
+} from '@mariozechner/pi-coding-agent';
+import {
+	BorderedLoader,
+	convertToLlm,
+	serializeConversation,
+} from '@mariozechner/pi-coding-agent';
 
-// Default export for Pi Package / additionalExtensionPaths loading
-export default async function handoff(pi: ExtensionAPI) {
-	const history: Array<{
-		role: string;
-		summary: string;
-		timestamp: number;
-	}> = [];
-
-	// Track conversation turns
-	pi.on('message_end', async (event) => {
-		const msg = event.message as unknown as Record<string, unknown>;
-		if (!msg) return;
-
-		const content = msg.content as
-			| Array<{ type: string; text?: string }>
-			| undefined;
-		if (!Array.isArray(content)) return;
-
-		const text = content
-			.filter((c) => c.type === 'text')
-			.map((c) => c.text || '')
-			.join('\n');
-
-		if (!text) return;
-
-		const summary =
-			text.length > 200 ? text.slice(0, 200) + '...' : text;
-
-		history.push({
-			role: (msg.role as string) || 'unknown',
-			summary,
-			timestamp: Date.now(),
-		});
-	});
+const SYSTEM_PROMPT = `You are a context transfer assistant. Given a conversation history and the user's goal for a new thread, generate a focused prompt that:
+
+1. Summarizes relevant context from the conversation (decisions made, approaches taken, key findings)
+2. Lists any relevant files that were discussed or modified
+3. Clearly states the next task based on the user's goal
+4. Is self-contained - the new thread should be able to proceed without the old conversation
+
+Format your response as a prompt the user can send to start the new thread. Be concise but include all necessary context. Do not include any preamble like "Here's the prompt" - just output the prompt itself.
+
+Example output format:
+## Context
+We've been working on X. Key decisions:
+- Decision 1
+- Decision 2
+
+Files involved:
+- path/to/file1.ts
+- path/to/file2.ts
+
+## Task
+[Clear description of what to do next based on user's goal]`;
 
+export default async function handoff(pi: ExtensionAPI) {
 	pi.registerCommand('handoff', {
 		description:
-			'Export session context as a handoff prompt for a new session',
+			'Transfer context to a new focused session with an AI-generated prompt',
 		handler: async (args, ctx) => {
-			const task = args.trim();
+			if (!ctx.hasUI) {
+				ctx.ui.notify('handoff requires interactive mode', 'error');
+				return;
+			}
+
+			if (!ctx.model) {
+				ctx.ui.notify('No model selected', 'error');
+				return;
+			}
 
-			if (history.length === 0) {
+			const goal = args.trim();
+			if (!goal) {
 				ctx.ui.notify(
-					'No conversation history to hand off',
-					'warning',
+					'Usage: /handoff <goal for new thread>',
+					'error',
 				);
 				return;
 			}
 
-			const context = history
-				.map((h) => `[${h.role}] ${h.summary}`)
-				.join('\n\n');
+			const branch = ctx.sessionManager.getBranch();
+			const messages = branch
+				.filter(
+					(entry): entry is SessionEntry & { type: 'message' } =>
+						entry.type === 'message',
+				)
+				.map((entry) => entry.message);
 
-			const handoff = `## Handoff from Previous Session
-
-### Context
-The previous session covered the following:
+			if (messages.length === 0) {
+				ctx.ui.notify('No conversation to hand off', 'error');
+				return;
+			}
 
-${context}
+			const llm_messages = convertToLlm(messages);
+			const conversation_text = serializeConversation(llm_messages);
+			const current_session_file =
+				ctx.sessionManager.getSessionFile();
+			const model = ctx.model;
+
+			const result = await ctx.ui.custom<string | null>(
+				(tui, theme, _kb, done) => {
+					const loader = new BorderedLoader(
+						tui,
+						theme,
+						'Generating handoff prompt...',
+					);
+					loader.onAbort = () => done(null);
+
+					const generate = async () => {
+						const auth =
+							await ctx.modelRegistry.getApiKeyAndHeaders(model);
+						if (!auth.ok || !auth.apiKey) {
+							throw new Error(
+								auth.ok
+									? `No API key for ${model.provider}`
+									: auth.error,
+							);
+						}
+
+						const user_message: Message = {
+							role: 'user',
+							content: [
+								{
+									type: 'text',
+									text: `## Conversation History\n\n${conversation_text}\n\n## User's Goal for New Thread\n\n${goal}`,
+								},
+							],
+							timestamp: Date.now(),
+						};
+
+						const response = await complete(
+							model,
+							{
+								systemPrompt: SYSTEM_PROMPT,
+								messages: [user_message],
+							},
+							{
+								apiKey: auth.apiKey,
+								headers: auth.headers,
+								signal: loader.signal,
+							},
+						);
+
+						if (response.stopReason === 'aborted') {
+							return null;
+						}
+
+						return response.content
+							.filter(
+								(c): c is { type: 'text'; text: string } =>
+									c.type === 'text',
+							)
+							.map((c) => c.text)
+							.join('\n');
+					};
+
+					generate()
+						.then(done)
+						.catch((err) => {
+							console.error('Handoff generation failed:', err);
+							done(null);
+						});
+
+					return loader;
+				},
+			);
 
-### Task
-${task || 'Continue from where the previous session left off.'}
+			if (result === null) {
+				ctx.ui.notify('Cancelled', 'info');
+				return;
+			}
 
-### Instructions
-- Review the context above to understand what was done
-- Do NOT repeat work that was already completed
-- Focus on the task described above
-`;
+			const edited_prompt = await ctx.ui.editor(
+				'Edit handoff prompt',
+				result,
+			);
+			if (edited_prompt === undefined) {
+				ctx.ui.notify('Cancelled', 'info');
+				return;
+			}
 
-			// Write to file
-			const filename = `handoff-${Date.now()}.md`;
-			const filepath = join(ctx.cwd, filename);
-			writeFileSync(filepath, handoff, 'utf-8');
+			const new_session_result = await ctx.newSession({
+				parentSession: current_session_file,
+			});
+			if (new_session_result.cancelled) {
+				ctx.ui.notify('New session cancelled', 'info');
+				return;
+			}
 
-			ctx.ui.notify(
-				`Handoff written to ${filename}\n\nUse: my-pi < ${filename}`,
-			);
+			ctx.ui.setEditorText(edited_prompt);
+			ctx.ui.notify('Handoff ready. Submit when ready.', 'info');
 		},
 	});
 }