pi-zellij 0.3.1

package/extensions/zv-continue.ts

@@ -0,0 +1,449 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SessionManager, type ExtensionAPI, type ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import {
+	buildPiCommand,
+	openCommandInNewSplit,
+	type SplitDirection,
+} from "./zv-core.ts";
+import {
+	ensureCreatedBranchWorktree,
+	getGitRepoInfo,
+	type GitRepoInfo,
+} from "./git-core.ts";
+
+const MAX_TEXT_LENGTH = 280;
+const TEMPLATE_DIR = join(dirname(fileURLToPath(import.meta.url)), "templates");
+
+const promptTemplateCache = new Map<string, string>();
+
+type ContinueRequest =
+	| { mode: "handoff"; note?: string }
+	| { mode: "worktree-create"; branch: string; fromRef?: string; note?: string };
+
+interface HandoffContext {
+	sourceCwd: string;
+	sourceSessionName?: string;
+	sourceSessionFile?: string;
+	currentTask?: string;
+	repo?: GitRepoInfo;
+	modifiedFiles: string[];
+	newFiles: string[];
+	otherStatusLines: string[];
+	note?: string;
+	fromRef?: string;
+	targetBranch?: string;
+	targetWorktreePath?: string;
+}
+
+interface HandoffTarget {
+	cwd: string;
+	sessionFile: string;
+	prompt: string;
+}
+
+interface MessageLike {
+	role?: string;
+	content?: unknown;
+}
+
+interface SessionMessageEntryLike {
+	type?: string;
+	message?: MessageLike;
+}
+
+function truncateText(text: string, maxLength: number = MAX_TEXT_LENGTH): string {
+	const trimmed = text.trim();
+	if (trimmed.length <= maxLength) return trimmed;
+	return `${trimmed.slice(0, maxLength - 3)}...`;
+}
+
+function normalizeWhitespace(text: string): string {
+	return text.replace(/\s+/g, " ").trim();
+}
+
+function getContinueUsage(commandName: string): string {
+	return `Usage: /${commandName} [note]  |  /${commandName} -c <branch> [--from <ref>] [note]`;
+}
+
+function parseContinueArgs(args: string): { ok: true; request: ContinueRequest } | { ok: false; error: string } {
+	const trimmed = args.trim();
+	if (!trimmed) {
+		return { ok: true, request: { mode: "handoff" } };
+	}
+
+	const tokens = trimmed.split(/\s+/).filter((token) => token.length > 0);
+	const [first, ...rest] = tokens;
+	if (first === "-t" || first === "--tree" || first === "--worktree") {
+		return { ok: false, error: "Existing-branch worktree mode is disabled for now; use -c <branch> to create a new worktree branch" };
+	}
+	if (first === "-c" || first === "--create") {
+		if (rest.length < 1) {
+			return { ok: false, error: "Create-worktree mode requires a branch name" };
+		}
+		const [branch, ...remaining] = rest;
+		let fromRef: string | undefined;
+		const noteParts: string[] = [];
+		for (let index = 0; index < remaining.length; index += 1) {
+			const token = remaining[index];
+			if (token === "--from" || token === "-f") {
+				const next = remaining[index + 1];
+				if (!next) {
+					return { ok: false, error: "--from requires a git ref" };
+				}
+				fromRef = next;
+				index += 1;
+				continue;
+			}
+			noteParts.push(token);
+		}
+		const note = noteParts.join(" ").trim() || undefined;
+		return { ok: true, request: { mode: "worktree-create", branch, fromRef, note } };
+	}
+	if (trimmed.startsWith("-")) {
+		return { ok: false, error: `Unknown flag: ${first}` };
+	}
+
+	return { ok: true, request: { mode: "handoff", note: trimmed } };
+}
+
+function isSessionMessageEntry(entry: unknown): entry is SessionMessageEntryLike {
+	return typeof entry === "object" && entry !== null && (entry as { type?: unknown }).type === "message";
+}
+
+function getMessageText(message: MessageLike | undefined): string | undefined {
+	if (!message) return undefined;
+	if (typeof message.content === "string") {
+		const text = normalizeWhitespace(message.content);
+		return text.length > 0 ? truncateText(text) : undefined;
+	}
+	if (!Array.isArray(message.content)) return undefined;
+	const text = message.content
+		.filter((part): part is { type: "text"; text: string } => {
+			return typeof part === "object" && part !== null && (part as { type?: unknown }).type === "text" && typeof (part as { text?: unknown }).text === "string";
+		})
+		.map((part) => normalizeWhitespace(part.text))
+		.filter((part) => part.length > 0)
+		.join(" ")
+		.trim();
+	return text.length > 0 ? truncateText(text) : undefined;
+}
+
+function isControlMessageText(text: string): boolean {
+	const trimmed = text.trim();
+	if (!trimmed) return true;
+	if (trimmed.startsWith("/") || trimmed.startsWith(":")) return true;
+	if (/^run (?:\/|:)reload/i.test(trimmed)) return true;
+	return false;
+}
+
+function isSyntheticHandoffText(text: string): boolean {
+	const trimmed = text.trim();
+	return trimmed.startsWith("Handoff context from another Pi pane:") || trimmed.startsWith("Continue the current task from this new pane.") || trimmed.startsWith("Continue the current task in this git worktree for branch ");
+}
+
+function isLowSignalTaskText(text: string): boolean {
+	const normalized = text.trim().toLowerCase();
+	if (!normalized) return true;
+	if ([
+		"yes",
+		"ok",
+		"okay",
+		"yep",
+		"yeah",
+		"sure",
+		"nice",
+		"cool",
+		"great",
+		"go ahead",
+		"do it",
+		"makes sense",
+		"ok makes sense",
+		"okay makes sense",
+	].includes(normalized)) {
+		return true;
+	}
+	return normalized.split(/\s+/).length === 1 && normalized.length <= 4;
+}
+
+function findRecentTaskText(entries: readonly unknown[]): string | undefined {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (!isSessionMessageEntry(entry) || entry.message?.role !== "user") continue;
+		const text = getMessageText(entry.message);
+		if (!text || isControlMessageText(text) || isSyntheticHandoffText(text) || isLowSignalTaskText(text)) continue;
+		return text;
+	}
+	return undefined;
+}
+
+function shouldIgnoreStatusPath(file: string): boolean {
+	return file === ".agents" || file.startsWith(".agents/") || file === ".pi" || file.startsWith(".pi/") || file === "node_modules" || file.startsWith("node_modules/");
+}
+
+function summarizeGitStatusLines(statusLines: readonly string[]): { modifiedFiles: string[]; newFiles: string[]; otherStatusLines: string[] } {
+	const modifiedFiles: string[] = [];
+	const newFiles: string[] = [];
+	const otherStatusLines: string[] = [];
+
+	for (const line of statusLines) {
+		const code = line.slice(0, 2);
+		const file = line.slice(3).trim();
+		if (!file || shouldIgnoreStatusPath(file)) {
+			continue;
+		}
+		if (code === "??") {
+			newFiles.push(file);
+			continue;
+		}
+		if (code.includes("M") || code.includes("A") || code.includes("D") || code.includes("R") || code.includes("C")) {
+			modifiedFiles.push(file);
+			continue;
+		}
+		otherStatusLines.push(line);
+	}
+
+	return { modifiedFiles, newFiles, otherStatusLines };
+}
+
+function buildHandoffSummary(context: HandoffContext, includeLineageHint: boolean): string {
+	const lines = ["Handoff context from another Pi pane:"];
+	lines.push(`- Source cwd: ${context.sourceCwd}`);
+	if (context.sourceSessionName) lines.push(`- Session name: ${context.sourceSessionName}`);
+	if (context.repo?.branch) lines.push(`- Source branch: ${context.repo.branch}`);
+	if (context.targetBranch) lines.push(`- Target branch: ${context.targetBranch}`);
+	if (context.fromRef) lines.push(`- Base ref: ${context.fromRef}`);
+	if (context.targetWorktreePath) lines.push(`- Target worktree: ${context.targetWorktreePath}`);
+	if (context.currentTask) lines.push(`- Current task: ${context.currentTask}`);
+	if (context.note) lines.push(`- Focus note: ${context.note}`);
+	if (context.modifiedFiles.length > 0) {
+		lines.push("- Modified files:");
+		for (const file of context.modifiedFiles) {
+			lines.push(`  ${file}`);
+		}
+	}
+	if (context.newFiles.length > 0) {
+		lines.push("- New files:");
+		for (const file of context.newFiles) {
+			lines.push(`  ${file}`);
+		}
+	}
+	if (context.otherStatusLines.length > 0) {
+		lines.push("- Other git status:");
+		for (const line of context.otherStatusLines) {
+			lines.push(`  ${line}`);
+		}
+	}
+	if (includeLineageHint) {
+		lines.push("- This session was forked from the current conversation path so prior context is already available here.");
+	}
+	return lines.join("\n");
+}
+
+function readPromptTemplate(name: string): string {
+	const cached = promptTemplateCache.get(name);
+	if (cached) return cached;
+	const template = readFileSync(join(TEMPLATE_DIR, name), "utf8");
+	promptTemplateCache.set(name, template);
+	return template;
+}
+
+function renderPromptTemplate(name: string, replacements: Record<string, string>): string {
+	let template = readPromptTemplate(name);
+	for (const [key, value] of Object.entries(replacements)) {
+		template = template.replaceAll(`{{${key}}}`, value);
+	}
+	return template.trim();
+}
+
+function buildFocusNoteSentence(note?: string): string {
+	return note ? ` Focus on: ${note}.` : "";
+}
+
+function buildSameCheckoutPrompt(note: string | undefined, inheritedHistory: boolean): string {
+	if (inheritedHistory) {
+		return renderPromptTemplate("handoff-same-checkout.md", {
+			FOCUS_NOTE_SENTENCE: buildFocusNoteSentence(note),
+		});
+	}
+	if (note) {
+		return `Continue the current task from this new pane. Focus on: ${note}. Use the handoff summary already present in this session. Start with the highest-priority next step.`;
+	}
+	return "Continue the current task from this new pane. Use the handoff summary already present in this session. Start with the highest-priority next step.";
+}
+
+function buildWorktreePrompt(branch: string, note?: string): string {
+	return renderPromptTemplate("handoff-worktree.md", {
+		TARGET_BRANCH: branch,
+		FOCUS_NOTE_SENTENCE: buildFocusNoteSentence(note),
+	});
+}
+
+function buildWorktreeBootstrapPrompt(branch: string, note?: string): string {
+	return buildWorktreePrompt(branch, note);
+}
+
+function appendUserMessage(sessionManager: SessionManager, text: string): void {
+	sessionManager.appendMessage({
+		role: "user",
+		content: text,
+		timestamp: Date.now(),
+	});
+}
+
+function createForkedSameCheckoutSession(ctx: ExtensionCommandContext, summary: string): string | undefined {
+	const currentSessionFile = ctx.sessionManager.getSessionFile();
+	const leafId = ctx.sessionManager.getLeafId();
+	if (!currentSessionFile || !leafId) return undefined;
+
+	const currentSession = SessionManager.open(currentSessionFile, ctx.sessionManager.getSessionDir());
+	const branchedSessionFile = currentSession.createBranchedSession(leafId);
+	if (!branchedSessionFile) return undefined;
+
+	const branchedSession = SessionManager.open(branchedSessionFile, ctx.sessionManager.getSessionDir());
+	appendUserMessage(branchedSession, summary);
+	return branchedSessionFile;
+}
+
+function createSummaryOnlySession(cwd: string, summary: string): string | undefined {
+	const sessionManager = SessionManager.create(cwd);
+	appendUserMessage(sessionManager, summary);
+	return sessionManager.getSessionFile();
+}
+
+async function buildHandoffContext(pi: ExtensionAPI, ctx: ExtensionCommandContext, note?: string): Promise<HandoffContext> {
+	const branchEntries = ctx.sessionManager.getBranch();
+	const repo = await getGitRepoInfo(pi, ctx.cwd);
+	const statusSummary = summarizeGitStatusLines(repo?.statusLines ?? []);
+	return {
+		sourceCwd: ctx.cwd,
+		sourceSessionName: ctx.sessionManager.getSessionName(),
+		sourceSessionFile: ctx.sessionManager.getSessionFile(),
+		currentTask: ctx.sessionManager.getSessionName() || findRecentTaskText(branchEntries),
+		repo,
+		modifiedFiles: statusSummary.modifiedFiles,
+		newFiles: statusSummary.newFiles,
+		otherStatusLines: statusSummary.otherStatusLines,
+		note,
+	};
+}
+
+async function resolveHandoffTarget(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	request: ContinueRequest,
+): Promise<{ ok: true; target: HandoffTarget } | { ok: false; error: string }> {
+	if (request.mode === "handoff") {
+		const context = await buildHandoffContext(pi, ctx, request.note);
+		const expectInheritedHistory = Boolean(context.sourceSessionFile && ctx.sessionManager.getLeafId());
+		const summary = buildHandoffSummary(context, expectInheritedHistory);
+		const forkedSessionFile = createForkedSameCheckoutSession(ctx, summary);
+		const sessionFile = forkedSessionFile || createSummaryOnlySession(ctx.cwd, summary);
+		if (!sessionFile) {
+			return { ok: false, error: "Failed to create a handoff session" };
+		}
+		return {
+			ok: true,
+			target: {
+				cwd: ctx.cwd,
+				sessionFile,
+				prompt: buildSameCheckoutPrompt(request.note, Boolean(forkedSessionFile)),
+			},
+		};
+	}
+
+	const repo = await getGitRepoInfo(pi, ctx.cwd);
+	if (!repo) {
+		return { ok: false, error: "Not inside a git repository" };
+	}
+
+	const worktreeResult = await ensureCreatedBranchWorktree(pi, repo.repoRoot, request.branch, request.fromRef);
+	if (!worktreeResult.ok) {
+		return worktreeResult;
+	}
+
+	const context = await buildHandoffContext(pi, ctx, request.note);
+	context.targetBranch = request.branch;
+	context.fromRef = request.fromRef;
+	context.targetWorktreePath = worktreeResult.path;
+	const summary = buildHandoffSummary(context, false);
+	const sessionFile = createSummaryOnlySession(worktreeResult.path, summary);
+	if (!sessionFile) {
+		return { ok: false, error: "Failed to create a worktree handoff session" };
+	}
+
+	return {
+		ok: true,
+		target: {
+			cwd: worktreeResult.path,
+			sessionFile,
+			prompt: buildWorktreeBootstrapPrompt(request.branch, request.note),
+		},
+	};
+}
+
+async function openContinueSplit(
+	pi: ExtensionAPI,
+	ctx: ExtensionCommandContext,
+	direction: SplitDirection,
+	request: ContinueRequest,
+): Promise<{ ok: true } | { ok: false; error: string }> {
+	const handoffTarget = await resolveHandoffTarget(pi, ctx, request);
+	if (!handoffTarget.ok) {
+		return handoffTarget;
+	}
+
+	return openCommandInNewSplit(
+		pi,
+		direction,
+		buildPiCommand(handoffTarget.target.cwd, {
+			sessionFile: handoffTarget.target.sessionFile,
+			prompt: handoffTarget.target.prompt,
+		}),
+	);
+}
+
+function registerContinueCommand(
+	pi: ExtensionAPI,
+	name: string,
+	direction: SplitDirection,
+	description: string,
+	successMessage: string,
+): void {
+	pi.registerCommand(name, {
+		description,
+		handler: async (args, ctx) => {
+			const parsed = parseContinueArgs(args);
+			if (!parsed.ok) {
+				ctx.ui.notify(`${parsed.error}. ${getContinueUsage(name)}`, "warning");
+				return;
+			}
+
+			const result = await openContinueSplit(pi, ctx, direction, parsed.request);
+			if (result.ok) {
+				ctx.ui.notify(successMessage, "info");
+			} else {
+				ctx.ui.notify(`continuation split failed: ${result.error}`, "error");
+			}
+		},
+	});
+}
+
+export default function zvContinueExtension(pi: ExtensionAPI) {
+	registerContinueCommand(
+		pi,
+		"zcv",
+		"right",
+		"Open a new right split and continue the current task, optionally in a git worktree",
+		"Opened a continuation split to the right",
+	);
+
+	registerContinueCommand(
+		pi,
+		"zch",
+		"down",
+		"Open a new lower split and continue the current task, optionally in a git worktree",
+		"Opened a continuation split below",
+	);
+}

package/extensions/zv-core.ts

@@ -0,0 +1,136 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+const ZELLIJ_TIMEOUT_MS = 5000;
+
+export type SplitDirection = "right" | "down";
+
+interface ZellijExecResult {
+	ok: boolean;
+	stdout: string;
+	stderr: string;
+	error?: string;
+}
+
+function isInsideZellijSession(): boolean {
+	return Boolean(process.env.ZELLIJ || process.env.ZELLIJ_SESSION_NAME || process.env.ZELLIJ_PANE_ID);
+}
+
+export function shellEscape(value: string): string {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+export function buildPiCommand(cwd: string, options?: { sessionFile?: string; prompt?: string }): string {
+	const commandParts = ["cd", shellEscape(cwd), "&&", "exec", "pi"];
+	if (options?.sessionFile) {
+		commandParts.push("--session", shellEscape(options.sessionFile));
+	}
+	const prompt = options?.prompt?.trim();
+	if (prompt) {
+		commandParts.push(shellEscape(prompt));
+	}
+	return commandParts.join(" ");
+}
+
+export function buildShellCommand(cwd: string, command: string): string {
+	return ["cd", shellEscape(cwd), "&&", "exec", "sh", "-lc", shellEscape(command)].join(" ");
+}
+
+async function execZellij(pi: ExtensionAPI, args: string[]): Promise<ZellijExecResult> {
+	const result = await pi.exec("zellij", args, { timeout: ZELLIJ_TIMEOUT_MS });
+	if (result.killed) {
+		return {
+			ok: false,
+			stdout: result.stdout,
+			stderr: result.stderr,
+			error: "zellij command timed out",
+		};
+	}
+	if (result.code !== 0) {
+		return {
+			ok: false,
+			stdout: result.stdout,
+			stderr: result.stderr,
+			error: result.stderr.trim() || result.stdout.trim() || `zellij exited with code ${result.code}`,
+		};
+	}
+	return {
+		ok: true,
+		stdout: result.stdout,
+		stderr: result.stderr,
+	};
+}
+
+export async function openCommandInNewSplit(
+	pi: ExtensionAPI,
+	direction: SplitDirection,
+	command: string,
+): Promise<{ ok: true } | { ok: false; error: string }> {
+	if (!isInsideZellijSession()) {
+		return { ok: false, error: "This command must be run from inside an active zellij session" };
+	}
+
+	const result = await execZellij(pi, ["run", "--direction", direction, "--", "sh", "-lc", command]);
+	if (!result.ok) {
+		return { ok: false, error: result.error || "Failed to open a new zellij pane" };
+	}
+
+	return { ok: true };
+}
+
+export async function openCommandInFloatingPane(
+	pi: ExtensionAPI,
+	command: string,
+	options?: { name?: string; width?: string; height?: string; x?: string; y?: string },
+): Promise<{ ok: true } | { ok: false; error: string }> {
+	if (!isInsideZellijSession()) {
+		return { ok: false, error: "This command must be run from inside an active zellij session" };
+	}
+
+	const args = ["run", "--floating"];
+	if (options?.name) args.push("--name", options.name);
+	if (options?.width) args.push("--width", options.width);
+	if (options?.height) args.push("--height", options.height);
+	if (options?.x) args.push("-x", options.x);
+	if (options?.y) args.push("-y", options.y);
+	args.push("--", "sh", "-lc", command);
+
+	const result = await execZellij(pi, args);
+	if (!result.ok) {
+		return { ok: false, error: result.error || "Failed to open a new floating zellij pane" };
+	}
+
+	return { ok: true };
+}
+
+export async function openCommandInNewTab(
+	pi: ExtensionAPI,
+	cwd: string,
+	command: string,
+	options?: { name?: string },
+): Promise<{ ok: true } | { ok: false; error: string }> {
+	if (!isInsideZellijSession()) {
+		return { ok: false, error: "This command must be run from inside an active zellij session" };
+	}
+
+	const newTabArgs = ["action", "new-tab", "--cwd", cwd];
+	if (options?.name) {
+		newTabArgs.push("--name", options.name);
+	}
+
+	const newTabResult = await execZellij(pi, newTabArgs);
+	if (!newTabResult.ok) {
+		return { ok: false, error: newTabResult.error || "Failed to open a new zellij tab" };
+	}
+
+	const writeCommandResult = await execZellij(pi, ["action", "write-chars", command]);
+	if (!writeCommandResult.ok) {
+		return { ok: false, error: writeCommandResult.error || "Failed to write command to new zellij tab" };
+	}
+
+	const submitCommandResult = await execZellij(pi, ["action", "write", "10"]);
+	if (!submitCommandResult.ok) {
+		return { ok: false, error: submitCommandResult.error || "Failed to start command in new zellij tab" };
+	}
+
+	return { ok: true };
+}