topchester-ai 0.45.0 → 0.47.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-BHctQstt.mjs";
 //#region src/bin.ts
 await runTopchesterCli();
 //#endregion

package/dist/{cli-BgMj4Ifj.mjs → cli-BHctQstt.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);
@@ -8758,6 +8799,9 @@ function isVisibleOnlyMessage(meta) {
 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 +9089,10 @@ const slashCommandSuggestions = [
 	{
 		value: "/new",
 		description: "start a fresh session"
+	},
+	{
+		value: "/fork",
+		description: "fork the current session"
 	}
 ];
 const slashCommands = [
@@ -9092,6 +9140,11 @@ const slashCommands = [
 		name: "new",
 		description: "start a fresh interactive TUI session",
 		execute: executeNewCommand
+	},
+	{
+		name: "fork",
+		description: "fork the current interactive TUI session",
+		execute: executeForkCommand
 	}
 ];
 function parseSlashCommand(input) {
@@ -9112,7 +9165,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, or /fork."] };
 	}
 	return command.execute(parsed.args, context);
 }
@@ -9209,6 +9262,9 @@ 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 executeInteractiveOnlyCommand(command) {
 	return () => ({ messages: [`${command} is available in the interactive TUI.`] });
 }
@@ -12933,6 +12989,9 @@ function getSlashCommandActivities(command) {
 function isNewSessionCommand(command) {
 	return command.trim() === "/new";
 }
+function isForkSessionCommand(command) {
+	return command.trim() === "/fork";
+}
 function isConnectCommand(command) {
 	const name = getSlashCommandName(command);
 	return name === "connect" || name === "provider" || name === "providers";
@@ -13298,6 +13357,10 @@ var TopchesterTuiShell = class {
 			await this.startNewSession(app, tui);
 			return;
 		}
+		if (isForkSessionCommand(command)) {
+			await this.forkCurrentSession(app, tui);
+			return;
+		}
 		if (isConnectCommand(command)) {
 			await this.submitConnectCommand(app, tui, command);
 			return;
@@ -13709,6 +13772,39 @@ 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 appendStartupRuntimeEvents(session, messages, events) {
 		for (const event of events) {
 			messages.push(...renderRuntimeEvent(event));
@@ -14284,6 +14380,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 +14480,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 +14553,4 @@ function formatDryRunSyncStatus(status) {
 //#endregion
 export { runTopchesterCli as t };
 
-//# sourceMappingURL=cli-BgMj4Ifj.mjs.map
+//# sourceMappingURL=cli-BHctQstt.mjs.map