topchester-ai 0.46.0 → 0.48.0

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as runTopchesterCli } from "./cli-BgMj4Ifj.mjs";
+import { t as runTopchesterCli } from "./cli-BZmxcvol.mjs";
 //#region src/bin.ts
 await runTopchesterCli();
 //#endregion

package/dist/{cli-BgMj4Ifj.mjs → cli-BZmxcvol.mjs}

@@ -8341,6 +8341,8 @@ const sessionMetadataSchema = z.object({
 	rootSessionId: z.string().optional(),
 	parentSessionId: z.string().optional(),
 	parentToolCallId: z.string().optional(),
+	forkedFromSessionId: z.string().optional(),
+	forkedFromRootSessionId: z.string().optional(),
 	source: z.enum(["user", "subagent"]).optional(),
 	agentProfileId: z.string().optional(),
 	title: z.string().optional(),
@@ -8553,6 +8555,45 @@ async function createChildSession(workspaceRoot, options) {
 	}));
 	return child;
 }
+async function forkSession(workspaceRoot, sourceSessionIdOrLatest, options = {}) {
+	const source = await loadSession(workspaceRoot, sourceSessionIdOrLatest);
+	const copiedEvents = await readFile(join(source.sessionDir, "events.jsonl"), "utf8");
+	const sessionsPath = getTopchesterSessionsPath(workspaceRoot);
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	for (let attempt = 0; attempt < 10; attempt += 1) {
+		const sessionId = generateSessionId();
+		const sessionDir = join(sessionsPath, sessionId);
+		const metadataPath = join(sessionDir, "metadata.json");
+		const eventsPath = join(sessionDir, "events.jsonl");
+		const metadata = {
+			version: 1,
+			sessionId,
+			rootSessionId: sessionId,
+			forkedFromSessionId: source.sessionId,
+			forkedFromRootSessionId: source.metadata.rootSessionId,
+			source: "user",
+			...options.title === void 0 ? {} : { title: options.title },
+			workspaceRoot,
+			createdAt,
+			updatedAt: createdAt,
+			lastEventId: source.metadata.lastEventId
+		};
+		try {
+			await mkdir(sessionDir);
+			await writeMetadata(metadataPath, metadata);
+			await writeFile(eventsPath, copiedEvents, { flag: "wx" });
+			return buildHandle(sessionDir, metadata);
+		} catch (error) {
+			if (isFileExistsError(error)) continue;
+			await rm(sessionDir, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+	}
+	throw new Error("Could not create forked session after repeated session id collisions");
+}
 async function loadSessionForAppend(workspaceRoot, sessionId) {
 	const loaded = await loadSession(workspaceRoot, sessionId);
 	return buildHandle(loaded.sessionDir, loaded.metadata);
@@ -8579,6 +8620,48 @@ async function loadSession(workspaceRoot, sessionIdOrLatest) {
 		events
 	};
 }
+async function listSessionSummaries(workspaceRoot, options = {}) {
+	if (options.excludeSessionId !== void 0) validateSessionId(options.excludeSessionId);
+	const sessionsPath = getTopchesterSessionsPath(workspaceRoot);
+	let entries;
+	try {
+		entries = await readdir(sessionsPath);
+	} catch {
+		return [];
+	}
+	const summaries = [];
+	for (const sessionId of entries.filter((entry) => SESSION_ID_PATTERN.test(entry)).sort()) {
+		if (options.excludeSessionId === sessionId) continue;
+		const sessionDir = join(sessionsPath, sessionId);
+		const metadataPath = join(sessionDir, "metadata.json");
+		const eventsPath = join(sessionDir, "events.jsonl");
+		let metadata;
+		let events;
+		try {
+			metadata = await readMetadata(metadataPath);
+			validateMetadataConsistency(metadata, sessionId, workspaceRoot, metadataPath);
+			if (metadata.source === "subagent" && options.includeSubagents !== true) continue;
+			events = await readEvents(eventsPath);
+			validateEventConsistency(metadata, events, eventsPath);
+		} catch {
+			continue;
+		}
+		const prompt = firstUserPrompt(events);
+		summaries.push({
+			sessionId,
+			createdAt: metadata.createdAt,
+			updatedAt: metadata.updatedAt,
+			...metadata.title === void 0 ? {} : { title: metadata.title },
+			...metadata.forkedFromSessionId === void 0 ? {} : { forkedFromSessionId: metadata.forkedFromSessionId },
+			...prompt === void 0 ? {} : { firstUserPrompt: prompt }
+		});
+	}
+	const sorted = summaries.sort((left, right) => {
+		const byUpdatedAt = right.updatedAt.localeCompare(left.updatedAt);
+		return byUpdatedAt === 0 ? right.sessionId.localeCompare(left.sessionId) : byUpdatedAt;
+	});
+	return options.limit === void 0 ? sorted : sorted.slice(0, Math.max(0, options.limit));
+}
 async function resolveLatestSessionId(workspaceRoot) {
 	const sessionsPath = getTopchesterSessionsPath(workspaceRoot);
 	let entries;
@@ -8755,9 +8838,18 @@ function formatZodError(error) {
 function isVisibleOnlyMessage(meta) {
 	return typeof meta === "object" && meta !== null && "visibleOnly" in meta && meta.visibleOnly === true;
 }
+function firstUserPrompt(events) {
+	for (const event of events) if (event.kind === "message" && event.role === "user" && !isVisibleOnlySlashCommandMessage(event.meta)) return event.text;
+}
+function isVisibleOnlySlashCommandMessage(meta) {
+	return typeof meta === "object" && meta !== null && "source" in meta && meta.source === "slash_command" && "visibleOnly" in meta && meta.visibleOnly === true;
+}
 function isFileNotFoundError(error) {
 	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+function isFileExistsError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
 //#endregion
 //#region src/tui/banner.ts
 const ASCII_BANNERS = [
@@ -9045,6 +9137,14 @@ const slashCommandSuggestions = [
 	{
 		value: "/new",
 		description: "start a fresh session"
+	},
+	{
+		value: "/fork",
+		description: "fork the current session"
+	},
+	{
+		value: "/restore",
+		description: "restore a previous session"
 	}
 ];
 const slashCommands = [
@@ -9092,6 +9192,16 @@ const slashCommands = [
 		name: "new",
 		description: "start a fresh interactive TUI session",
 		execute: executeNewCommand
+	},
+	{
+		name: "fork",
+		description: "fork the current interactive TUI session",
+		execute: executeForkCommand
+	},
+	{
+		name: "restore",
+		description: "restore a previous interactive TUI session",
+		execute: executeRestoreCommand
 	}
 ];
 function parseSlashCommand(input) {
@@ -9112,7 +9222,7 @@ async function executeSlashCommand(input, context) {
 	if (!command) {
 		const shortcutResult = await executeSkillShortcutCommand(parsed.name, parsed.args, context);
 		if (shortcutResult) return shortcutResult;
-		return { messages: [`Unknown command: /${parsed.name}`, "Try /kb status or /new."] };
+		return { messages: [`Unknown command: /${parsed.name}`, "Try /kb status, /new, /fork, or /restore."] };
 	}
 	return command.execute(parsed.args, context);
 }
@@ -9209,6 +9319,12 @@ async function executeKbCommand(args, context) {
 function executeNewCommand() {
 	return { messages: ["/new starts a fresh session in the interactive TUI."] };
 }
+function executeForkCommand() {
+	return { messages: ["/fork clones the current session in the interactive TUI."] };
+}
+function executeRestoreCommand() {
+	return { messages: ["/restore opens a previous-session picker in the interactive TUI."] };
+}
 function executeInteractiveOnlyCommand(command) {
 	return () => ({ messages: [`${command} is available in the interactive TUI.`] });
 }
@@ -9575,6 +9691,9 @@ var ChatLayout = class {
 	submitMessage;
 	submitCommand;
 	modalActionHandler;
+	sessionPicker;
+	sessionPickerSelectionHandler;
+	sessionPickerCancelHandler;
 	activeModalActionIndex = 0;
 	activeSlashSuggestionIndex = 0;
 	threadScrollOffset = 0;
@@ -9666,12 +9785,34 @@ var ChatLayout = class {
 	setModalActionHandler(handler) {
 		this.modalActionHandler = handler;
 	}
+	setSessionPickerHandlers(handlers) {
+		this.sessionPickerSelectionHandler = handlers.select;
+		this.sessionPickerCancelHandler = handlers.cancel;
+	}
+	openSessionPicker(items) {
+		this.sessionPicker = {
+			items,
+			selectedIndex: 0,
+			scrollOffset: 0
+		};
+		this.threadScrollOffset = 0;
+	}
+	closeSessionPicker() {
+		this.sessionPicker = void 0;
+	}
+	isSessionPickerOpen() {
+		return this.sessionPicker !== void 0;
+	}
 	setInputValue(value) {
 		this.promptValue = value;
 		this.promptCursor = value.length;
 		this.pastedContent.clear();
 		this.pasteCounter = 0;
 	}
+	discardLastUserMessage(text) {
+		const last = this.messages.at(-1);
+		if (last?.kind === "user" && last.text === text) this.messages.pop();
+	}
 	resetForNewSession(messages) {
 		this.messages.splice(0, this.messages.length, ...messages);
 		this.promptValue = "";
@@ -9688,6 +9829,9 @@ var ChatLayout = class {
 		this.taskPlan = void 0;
 		this.cancelPending = void 0;
 		this.modalActionHandler = void 0;
+		this.sessionPicker = void 0;
+		this.sessionPickerSelectionHandler = void 0;
+		this.sessionPickerCancelHandler = void 0;
 		this.activeModalActionIndex = 0;
 		this.activeSlashSuggestionIndex = 0;
 		this.threadScrollOffset = 0;
@@ -9724,6 +9868,7 @@ var ChatLayout = class {
 		this.inputFocused = value;
 	}
 	handleInput(data) {
+		if (this.handleSessionPickerInput(data)) return;
 		if (this.handleModalInput(data)) return;
 		if (this.cancelPending && matchesKey(data, "escape")) {
 			this.cancelPending();
@@ -9741,7 +9886,7 @@ var ChatLayout = class {
 	invalidate() {}
 	render(width) {
 		const safeWidth = Math.max(20, width);
-		const footerLines = this.getActiveModal() ? this.renderModalHelp(safeWidth) : this.renderPrompt(safeWidth);
+		const footerLines = this.getActiveModal() && !this.sessionPicker ? this.renderModalHelp(safeWidth) : this.renderPrompt(safeWidth);
 		const threadHeight = Math.max(1, this.terminal.rows - footerLines.length);
 		const allThreadLines = this.renderThread(safeWidth, threadHeight);
 		if (this.transcriptMode === "inline") {
@@ -9761,6 +9906,7 @@ var ChatLayout = class {
 		}
 	}
 	renderThread(width, threadHeight) {
+		if (this.sessionPicker) return this.renderSessionPicker(width, threadHeight);
 		const innerWidth = Math.max(1, width);
 		const activeModalIndex = this.getActiveModalIndex();
 		const lines = this.messages.flatMap((message, index) => {
@@ -9787,7 +9933,7 @@ var ChatLayout = class {
 		});
 	}
 	renderPrompt(width) {
-		const slashSuggestions = this.getSlashSuggestions();
+		const slashSuggestions = this.sessionPicker ? [] : this.getSlashSuggestions();
 		const top = `┌${"─".repeat(Math.max(0, width - 2))}┐`;
 		const bottom = `└${"─".repeat(Math.max(0, width - 2))}┘`;
 		const prefix = "> ";
@@ -9884,6 +10030,74 @@ var ChatLayout = class {
 		const status = formatStatusLine(this.folderName, this.modelLabel, this.status, this.knowledgeStatus, statusInnerWidth);
 		return [truncateToWidth(`  ${help}`, width, "…", true), truncateToWidth(`  ${status}`, width, "…", true)];
 	}
+	renderSessionPicker(width, threadHeight) {
+		const picker = this.sessionPicker;
+		if (!picker) return [];
+		const innerWidth = Math.max(1, width);
+		const header = truncateToWidth(" Restore previous session", innerWidth, "…", true);
+		const help = truncateToWidth(" Up/Down move   Enter restore   Esc cancel", innerWidth, "…", true);
+		const availableRows = Math.max(1, threadHeight - 3);
+		const items = picker.items;
+		if (items.length === 0) return padLines([
+			padThreadLine(ui.label(header), width),
+			padThreadLine("", width),
+			padThreadLine(ui.muted(" No previous sessions for this workspace."), width),
+			padThreadLine(ui.muted(help), width)
+		], threadHeight, width);
+		picker.selectedIndex = Math.max(0, Math.min(picker.selectedIndex, items.length - 1));
+		picker.scrollOffset = getVisibleSuggestionWindowStart(items.length, picker.selectedIndex, availableRows);
+		const visibleItems = items.slice(picker.scrollOffset, picker.scrollOffset + availableRows);
+		return padLines([
+			padThreadLine(ui.label(header), width),
+			padThreadLine(ui.muted(help), width),
+			padThreadLine("", width),
+			...visibleItems.map((item, index) => {
+				const selected = picker.scrollOffset + index === picker.selectedIndex;
+				const row = formatSessionPickerRow(item, selected, innerWidth);
+				return selected ? ui.softBackground(padThreadLine(row, width)) : padThreadLine(row, width);
+			})
+		], threadHeight, width);
+	}
+	handleSessionPickerInput(data) {
+		const picker = this.sessionPicker;
+		if (!picker) return false;
+		if (matchesKey(data, "escape")) {
+			this.closeSessionPicker();
+			this.sessionPickerCancelHandler?.();
+			return true;
+		}
+		if (picker.items.length === 0) return true;
+		if (isUpKey(data)) {
+			picker.selectedIndex = Math.max(0, picker.selectedIndex - 1);
+			return true;
+		}
+		if (isDownKey(data)) {
+			picker.selectedIndex = Math.min(picker.items.length - 1, picker.selectedIndex + 1);
+			return true;
+		}
+		if (isPageUpKey(data)) {
+			picker.selectedIndex = Math.max(0, picker.selectedIndex - Math.max(1, Math.floor(this.terminal.rows / 2)));
+			return true;
+		}
+		if (isPageDownKey(data)) {
+			picker.selectedIndex = Math.min(picker.items.length - 1, picker.selectedIndex + Math.max(1, Math.floor(this.terminal.rows / 2)));
+			return true;
+		}
+		if (isHomeKey(data)) {
+			picker.selectedIndex = 0;
+			return true;
+		}
+		if (isEndKey(data)) {
+			picker.selectedIndex = picker.items.length - 1;
+			return true;
+		}
+		if (matchesKey(data, "enter") || data === "\n" || data === "\r") {
+			const item = picker.items[picker.selectedIndex];
+			if (item) this.sessionPickerSelectionHandler?.(item.sessionId);
+			return true;
+		}
+		return true;
+	}
 	handleModalInput(data) {
 		const activeModal = this.getActiveModal();
 		if (!activeModal) return false;
@@ -10218,6 +10432,17 @@ function getVisibleSuggestionWindowStart(total, activeIndex, visibleRows) {
 	if (total <= visibleRows) return 0;
 	return Math.max(0, Math.min(activeIndex - visibleRows + 1, total - visibleRows));
 }
+function formatSessionPickerRow(item, selected, width) {
+	return truncateToWidth(`${selected ? ">" : " "} ${formatSessionPickerDate(item.updatedAt)} ${item.sessionId.slice(0, 8)} ${formatSessionPickerPrompt(item.firstUserPrompt)}`, width, "…", true);
+}
+function formatSessionPickerDate(updatedAt) {
+	const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/u.exec(updatedAt);
+	return match ? `${match[1]} ${match[2]}` : updatedAt.slice(0, 16).replace("T", " ");
+}
+function formatSessionPickerPrompt(prompt) {
+	const normalized = prompt?.replace(/\s+/gu, " ").trim();
+	return normalized && normalized.length > 0 ? normalized : "(no user prompt)";
+}
 function colorUserMessageBorder(line) {
 	return line.replace("▌", ui.modelInline("▌"));
 }
@@ -12933,6 +13158,12 @@ function getSlashCommandActivities(command) {
 function isNewSessionCommand(command) {
 	return command.trim() === "/new";
 }
+function isForkSessionCommand(command) {
+	return command.trim() === "/fork";
+}
+function isRestoreSessionCommand(command) {
+	return command.trim() === "/restore";
+}
 function isConnectCommand(command) {
 	const name = getSlashCommandName(command);
 	return name === "connect" || name === "provider" || name === "providers";
@@ -13298,6 +13529,14 @@ var TopchesterTuiShell = class {
 			await this.startNewSession(app, tui);
 			return;
 		}
+		if (isForkSessionCommand(command)) {
+			await this.forkCurrentSession(app, tui);
+			return;
+		}
+		if (isRestoreSessionCommand(command)) {
+			await this.openRestoreSessionPicker(app, tui, command);
+			return;
+		}
 		if (isConnectCommand(command)) {
 			await this.submitConnectCommand(app, tui, command);
 			return;
@@ -13709,6 +13948,108 @@ var TopchesterTuiShell = class {
 		tui.requestRender();
 		await this.checkAgent(app, tui);
 	}
+	async forkCurrentSession(app, tui) {
+		if (this.taskPlanNoticeTimer) {
+			clearTimeout(this.taskPlanNoticeTimer);
+			this.taskPlanNoticeTimer = void 0;
+		}
+		const sourceSession = this.session;
+		if (!sourceSession) {
+			app.addMessage(systemMessage("Fork failed: no active session."));
+			tui.requestRender();
+			return;
+		}
+		const fork = await forkSession(this.context.workspaceRoot, sourceSession.sessionId);
+		const rehydrated = rehydrateSession((await loadSession(this.context.workspaceRoot, fork.sessionId)).events);
+		const forkNoticeText = `Forked session from ${sourceSession.sessionId.slice(0, 8)}.`;
+		const forkNotice = systemMessage(forkNoticeText);
+		const resetMessages = [...rehydrated.messages, forkNotice];
+		this.session = fork;
+		this.sessionStartedAt = Date.now();
+		this.pendingSkillActivations = [];
+		try {
+			await fork.append({
+				kind: "message",
+				role: "system",
+				text: forkNoticeText
+			});
+		} catch (error) {
+			resetMessages.push(systemMessage(`Session save failed: ${formatPlainError(error)}`));
+		}
+		app.resetForNewSession(resetMessages);
+		app.setTaskPlan(rehydrated.taskPlan);
+		if (rehydrated.status) app.setStatus(rehydrated.status);
+		tui.requestRender();
+	}
+	async openRestoreSessionPicker(app, tui, command) {
+		app.discardLastUserMessage(command);
+		const activeSession = this.session;
+		if (!activeSession) {
+			app.addMessage(systemMessage("Restore failed: no active session."));
+			tui.requestRender();
+			return;
+		}
+		if (!app.isReady()) {
+			app.addMessage(systemMessage("Restore is unavailable while another operation is running."));
+			tui.requestRender();
+			return;
+		}
+		const summaries = await listSessionSummaries(this.context.workspaceRoot, { excludeSessionId: activeSession.sessionId });
+		app.setSessionPickerHandlers({
+			select: (sessionId) => {
+				this.startBackgroundTask(app, tui, "Restore", () => this.restoreSelectedSession(app, tui, sessionId));
+			},
+			cancel: () => {
+				tui.requestRender();
+			}
+		});
+		app.openSessionPicker(summaries.map((summary) => ({
+			sessionId: summary.sessionId,
+			updatedAt: summary.updatedAt,
+			...summary.firstUserPrompt === void 0 ? {} : { firstUserPrompt: summary.firstUserPrompt }
+		})));
+		tui.requestRender();
+	}
+	async restoreSelectedSession(app, tui, sessionId) {
+		let restoredSession;
+		let restoredMessages;
+		let restoredTaskPlan;
+		let restoredStatus;
+		try {
+			restoredSession = await loadSessionForAppend(this.context.workspaceRoot, sessionId);
+			const rehydrated = rehydrateSession((await loadSession(this.context.workspaceRoot, sessionId)).events);
+			restoredTaskPlan = rehydrated.taskPlan;
+			restoredStatus = rehydrated.status;
+			const noticeText = `Restored session ${sessionId.slice(0, 8)}.`;
+			restoredMessages = [...rehydrated.messages, systemMessage(noticeText)];
+			this.session = restoredSession;
+			this.sessionStartedAt = Date.now();
+			this.pendingSkillActivations = [];
+			if (this.taskPlanNoticeTimer) {
+				clearTimeout(this.taskPlanNoticeTimer);
+				this.taskPlanNoticeTimer = void 0;
+			}
+			try {
+				await restoredSession.append({
+					kind: "message",
+					role: "system",
+					text: noticeText
+				});
+			} catch (error) {
+				restoredMessages.push(systemMessage(`Session save failed: ${formatPlainError(error)}`));
+			}
+		} catch (error) {
+			app.closeSessionPicker();
+			app.addMessage(systemMessage(`Restore failed: ${formatPlainError(error)}`));
+			tui.requestRender();
+			return;
+		}
+		app.closeSessionPicker();
+		app.resetForNewSession(restoredMessages);
+		app.setTaskPlan(restoredTaskPlan);
+		if (restoredStatus) app.setStatus(restoredStatus);
+		tui.requestRender();
+	}
 	async appendStartupRuntimeEvents(session, messages, events) {
 		for (const event of events) {
 			messages.push(...renderRuntimeEvent(event));
@@ -14284,6 +14625,18 @@ function createTopchesterProgram() {
 			process.exitCode = 1;
 		}
 	});
+	program.command("fork").description("fork a saved project session").argument("[session]", "session id to fork").option("--last", "fork the latest project session").action(async (sessionId, options) => {
+		const context = createContextFromOptions(program);
+		try {
+			if (options.last && sessionId) throw new Error("Usage: topchester fork [--last] [session-id]");
+			const source = options.last ? "latest" : sessionId;
+			if (!source) throw new Error("topchester fork requires --last or a session id until a saved-session picker exists.");
+			await openForkedSession(context, source);
+		} catch (error) {
+			console.error(formatStartupError(error));
+			process.exitCode = 1;
+		}
+	});
 	program.command("search").description("search compiled L1 knowledge entries").argument("<query...>", "search query").option("--limit <count>", "maximum number of matches", parsePositiveInteger).option("--json", "write full JSON search result to stdout").action(async (queryParts, options) => {
 		await executeKbSearchCommand(program, queryParts, options);
 	});
@@ -14372,6 +14725,17 @@ function printStartupSummary(context) {
 		}
 	}
 }
+async function openForkedSession(context, sourceSession) {
+	const fork = await forkSession(context.workspaceRoot, sourceSession);
+	const loaded = await loadSession(context.workspaceRoot, fork.sessionId);
+	const session = await loadSessionForAppend(context.workspaceRoot, loaded.sessionId);
+	const rehydrated = rehydrateSession(loaded.events);
+	await new TopchesterTuiShell(context, void 0, {
+		session,
+		initialMessages: rehydrated.messages,
+		initialTaskPlan: rehydrated.taskPlan
+	}).render();
+}
 function createContextFromOptions(program) {
 	return createAppContext(getContextOptionsFromProgram(program));
 }
@@ -14434,4 +14798,4 @@ function formatDryRunSyncStatus(status) {
 //#endregion
 export { runTopchesterCli as t };
 
-//# sourceMappingURL=cli-BgMj4Ifj.mjs.map
+//# sourceMappingURL=cli-BZmxcvol.mjs.map