@dimi-agent/cli 0.6.1 → 0.6.2

package/dist/main.mjs

@@ -378194,6 +378194,21 @@ var init_tool_call = __esmMin((() => {
 		get toolCallView() {
 			return this.toolCall;
 		}
+		/**
+		* Whether this call has reached a terminal state. Ordinary tools finish when
+		* their result lands; agent and read cards derive their phase from events
+		* (subagent lifecycle / read status), falling back to the result. Used by
+		* transcript folding to avoid collapsing calls the user still needs to
+		* watch (a running agent would otherwise disappear into the summary line).
+		*/
+		isFinished() {
+			if (this.toolCall.name === "Agent" || this.toolCall.name === "AgentSwarm") {
+				const phase = this.getSubagentSnapshot().phase;
+				return phase === "done" || phase === "failed" || phase === "backgrounded";
+			}
+			if (this.toolCall.name === "Read") return this.getReadSnapshot().phase !== "pending";
+			return this.result !== void 0;
+		}
 		/** Notifies the listener when internal state changes, if a group is attached. */
 		notifySnapshotChange() {
 			this.onSnapshotChange?.();
@@ -387216,6 +387231,82 @@ var init_terminal_notification = __esmMin((() => {
 	init_terminal();
 }));
 //#endregion
+//#region src/tui/utils/transcript-window.ts
+/**
+* Read a non-negative integer env var, falling back to `fallback` when it is
+* unset, empty, negative, or not an integer. `0` is a valid value (call sites
+* treat it as "feature disabled").
+*/
+function readEnvInt(name, fallback) {
+	const raw = process.env[name];
+	if (raw === void 0 || raw.trim() === "") return fallback;
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value < 0) return fallback;
+	return value;
+}
+/**
+* Group consecutive entries into turns by `turnId`. Entries with the same
+* non-undefined `turnId` that are adjacent belong to the same turn.
+*
+* Entries with an undefined `turnId` are buffered and attached to the *next*
+* defined turn. This matters because a user message is appended (with
+* `turnId: undefined`) before its turn actually starts, so without this
+* buffering every user message would become its own single-entry turn at the
+* front and get trimmed first. Any undefined entries left at the tail (no
+* following turn) become their own turn.
+*/
+function groupTurns(entries) {
+	const turns = [];
+	let current;
+	let pendingUndefined = [];
+	for (const entry of entries) {
+		const turnId = entry.turnId;
+		if (turnId === void 0) {
+			pendingUndefined.push(entry);
+			continue;
+		}
+		if (current !== void 0 && current.turnId === turnId) current.entries.push(entry);
+		else {
+			current = {
+				turnId,
+				entries: [...pendingUndefined, entry]
+			};
+			pendingUndefined = [];
+			turns.push(current);
+		}
+	}
+	if (pendingUndefined.length > 0) turns.push({
+		turnId: void 0,
+		entries: pendingUndefined
+	});
+	return turns;
+}
+/**
+* Decide which entries to destroy so the remaining turns fit within
+* `maxTurns`. Returns an empty set when the turn count is within
+* `maxTurns + hysteresis`. Oldest turns are removed first; the most recent
+* turn is never removed (it is the active / just-finished turn).
+*/
+function turnsToTrim(turns, maxTurns, hysteresis) {
+	const toRemove = /* @__PURE__ */ new Set();
+	if (turns.length <= maxTurns + hysteresis) return toRemove;
+	let remaining = turns.length;
+	for (let i = 0; i < turns.length - 1 && remaining > maxTurns; i++) {
+		const turn = turns[i];
+		for (const entry of turn.entries) toRemove.add(entry);
+		remaining--;
+	}
+	return toRemove;
+}
+var TRANSCRIPT_MAX_TURNS, TRANSCRIPT_EXPAND_TURNS, TRANSCRIPT_HYSTERESIS, TRANSCRIPT_KEEP_RECENT_STEPS, TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS;
+var init_transcript_window = __esmMin((() => {
+	TRANSCRIPT_MAX_TURNS = readEnvInt("DIMI_CODE_TUI_MAX_TURNS", 15);
+	TRANSCRIPT_EXPAND_TURNS = readEnvInt("DIMI_CODE_TUI_EXPAND_TURNS", 3);
+	TRANSCRIPT_HYSTERESIS = readEnvInt("DIMI_CODE_TUI_HYSTERESIS", 5);
+	TRANSCRIPT_KEEP_RECENT_STEPS = readEnvInt("DIMI_CODE_TUI_KEEP_RECENT_STEPS", 30);
+	TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS = readEnvInt("DIMI_CODE_TUI_KEEP_TRAILING_TOOL_CALLS", 2);
+}));
+//#endregion
 //#region src/tui/controllers/streaming-ui.ts
 var StreamingUIController;
 var init_streaming_ui = __esmMin((() => {
@@ -387231,6 +387322,7 @@ var init_streaming_ui = __esmMin((() => {
 	init_event_payload();
 	init_terminal_notification();
 	init_transcript_id();
+	init_transcript_window();
 	StreamingUIController = class {
 		host;
 		flushTimer;
@@ -387714,6 +387806,7 @@ var init_streaming_ui = __esmMin((() => {
 				state.transcriptContainer.addChild(tc);
 				state.ui.requestRender();
 			}
+			this.host.foldTrailingToolCalls(TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS);
 			if (toolCall.name === "ExitPlanMode" && typeof toolCall.args["plan"] !== "string") {
 				const session = this.host.requireSession();
 				(async () => {
@@ -390462,81 +390555,6 @@ var init_tmux_keyboard = __esmMin((() => {
 	TMUX_EXTENDED_KEYS_FORMAT_XTERM_WARNING = "tmux extended-keys-format is xterm. Dimi works best with csi-u. Add `set -g extended-keys-format csi-u` to ~/.tmux.conf and restart tmux.";
 }));
 //#endregion
-//#region src/tui/utils/transcript-window.ts
-/**
-* Read a non-negative integer env var, falling back to `fallback` when it is
-* unset, empty, negative, or not an integer. `0` is a valid value (call sites
-* treat it as "feature disabled").
-*/
-function readEnvInt(name, fallback) {
-	const raw = process.env[name];
-	if (raw === void 0 || raw.trim() === "") return fallback;
-	const value = Number(raw);
-	if (!Number.isInteger(value) || value < 0) return fallback;
-	return value;
-}
-/**
-* Group consecutive entries into turns by `turnId`. Entries with the same
-* non-undefined `turnId` that are adjacent belong to the same turn.
-*
-* Entries with an undefined `turnId` are buffered and attached to the *next*
-* defined turn. This matters because a user message is appended (with
-* `turnId: undefined`) before its turn actually starts, so without this
-* buffering every user message would become its own single-entry turn at the
-* front and get trimmed first. Any undefined entries left at the tail (no
-* following turn) become their own turn.
-*/
-function groupTurns(entries) {
-	const turns = [];
-	let current;
-	let pendingUndefined = [];
-	for (const entry of entries) {
-		const turnId = entry.turnId;
-		if (turnId === void 0) {
-			pendingUndefined.push(entry);
-			continue;
-		}
-		if (current !== void 0 && current.turnId === turnId) current.entries.push(entry);
-		else {
-			current = {
-				turnId,
-				entries: [...pendingUndefined, entry]
-			};
-			pendingUndefined = [];
-			turns.push(current);
-		}
-	}
-	if (pendingUndefined.length > 0) turns.push({
-		turnId: void 0,
-		entries: pendingUndefined
-	});
-	return turns;
-}
-/**
-* Decide which entries to destroy so the remaining turns fit within
-* `maxTurns`. Returns an empty set when the turn count is within
-* `maxTurns + hysteresis`. Oldest turns are removed first; the most recent
-* turn is never removed (it is the active / just-finished turn).
-*/
-function turnsToTrim(turns, maxTurns, hysteresis) {
-	const toRemove = /* @__PURE__ */ new Set();
-	if (turns.length <= maxTurns + hysteresis) return toRemove;
-	let remaining = turns.length;
-	for (let i = 0; i < turns.length - 1 && remaining > maxTurns; i++) {
-		const turn = turns[i];
-		for (const entry of turn.entries) toRemove.add(entry);
-		remaining--;
-	}
-	return toRemove;
-}
-var TRANSCRIPT_MAX_TURNS, TRANSCRIPT_EXPAND_TURNS, TRANSCRIPT_HYSTERESIS, TRANSCRIPT_KEEP_RECENT_STEPS;
-var init_transcript_window = __esmMin((() => {
-	TRANSCRIPT_MAX_TURNS = readEnvInt("DIMI_CODE_TUI_MAX_TURNS", 15);
-	TRANSCRIPT_EXPAND_TURNS = readEnvInt("DIMI_CODE_TUI_EXPAND_TURNS", 3);
-	TRANSCRIPT_HYSTERESIS = readEnvInt("DIMI_CODE_TUI_HYSTERESIS", 5);
-	TRANSCRIPT_KEEP_RECENT_STEPS = readEnvInt("DIMI_CODE_TUI_KEEP_RECENT_STEPS", 30);
-}));
-//#endregion
 //#region src/tui/dimi-tui.ts
 function loadingTipKind(mode) {
 	if (mode === "waiting" || mode === "tool") return "moon";
@@ -391895,6 +391913,7 @@ var init_dimi_tui = __esmMin((() => {
 				markTranscriptComponent(component, entry);
 				this.state.transcriptContainer.addChild(component);
 			}
+			if (entry.kind === "tool_call") this.foldTrailingToolCalls(TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS);
 			const trimmed = this.trimTranscriptWindow();
 			const merged = this.mergeCurrentTurnSteps();
 			if (component || trimmed || merged) this.state.ui.requestRender();
@@ -391999,6 +392018,21 @@ var init_dimi_tui = __esmMin((() => {
 			return this.foldCurrentTurnSteps(TRANSCRIPT_KEEP_RECENT_STEPS);
 		}
 		collapseTrailingToolCalls() {
+			this.foldTrailingToolCalls(0);
+		}
+		/**
+		* Fold the trailing contiguous run of tool calls, keeping the most recent
+		* `keepExpanded` calls expanded. `keepExpanded = 0` collapses the whole run
+		* (used when visible content follows, e.g. an assistant message or turn
+		* end); a positive cap folds progressively while the run is still growing
+		* so older calls merge into the summary immediately instead of staying
+		* expanded until the run ends.
+		*
+		* Only finished calls fold — a call that is still running (streaming args,
+		* a live subagent, a pending read) stays visible because its progress is
+		* live information the user is watching.
+		*/
+		foldTrailingToolCalls(keepExpanded) {
 			const children = this.state.transcriptContainer.children;
 			let start = children.length;
 			const toolCalls = [];
@@ -392020,21 +392054,49 @@ var init_dimi_tui = __esmMin((() => {
 			const standaloneNames = new Set(["AllDone", "WaitFor"]);
 			const standaloneCalls = new Set(toolCalls.filter((call) => standaloneNames.has(call.toolCallView.name)));
 			const sequenceCalls = toolCalls.filter((call) => !standaloneCalls.has(call));
+			if (sequenceCalls.length === 0) return;
+			const foldCount = sequenceCalls.length - keepExpanded;
+			if (foldCount <= 0) return;
 			const components = children.slice(start);
 			const standalone = [];
 			const sequenceComponents = [];
+			const keptComponents = [];
+			let remainingToFold = foldCount;
+			let stoppedAtUnfinished = false;
 			for (const component of components) {
-				if (component instanceof ToolCallSequenceComponent) {
-					sequenceComponents.push(...component.children);
-					component.clear();
+				if (stoppedAtUnfinished) {
+					keptComponents.push(component);
 					continue;
 				}
-				if (component instanceof ToolCallComponent && standaloneCalls.has(component)) standalone.push(component);
-				else sequenceComponents.push(component);
-			}
-			if (sequenceCalls.length === 0) return;
-			const sequence = new ToolCallSequenceComponent(sequenceComponents, sequenceCalls, this.state.toolDisplayMode);
-			children.splice(start, components.length, sequence, ...standalone);
+				if (component instanceof ToolCallComponent && standaloneCalls.has(component)) {
+					standalone.push(component);
+					continue;
+				}
+				const calls = toolCallsIn(component);
+				const callCount = calls?.filter((call) => !standaloneCalls.has(call)).length ?? 0;
+				const hasUnfinished = calls?.some((call) => !call.isFinished()) ?? false;
+				if (remainingToFold > 0 && hasUnfinished) {
+					keptComponents.push(component);
+					stoppedAtUnfinished = true;
+					continue;
+				}
+				if (remainingToFold > 0) {
+					if (component instanceof ToolCallSequenceComponent) {
+						sequenceComponents.push(...component.children);
+						component.clear();
+					} else sequenceComponents.push(component);
+					remainingToFold -= callCount;
+				} else keptComponents.push(component);
+			}
+			if (sequenceComponents.length === 0) return;
+			const foldedCalls = [];
+			for (const component of sequenceComponents) {
+				const componentCalls = toolCallsIn(component);
+				if (componentCalls !== void 0) foldedCalls.push(...componentCalls.filter((call) => !standaloneCalls.has(call)));
+			}
+			if (foldedCalls.length === 0) return;
+			const sequence = new ToolCallSequenceComponent(sequenceComponents, foldedCalls, this.state.toolDisplayMode);
+			children.splice(start, components.length, sequence, ...standalone, ...keptComponents);
 			this.state.transcriptContainer.invalidate();
 		}
 		foldCurrentTurnSteps(keepSteps) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimi-agent/cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "The Starting Point for Next-Gen Agents",
   "keywords": [
     "agent",
@@ -60,12 +60,12 @@
     "tsx": "^4.21.0",
     "yazl": "^3.3.1",
     "zod": "^4.3.6",
-    "@dimi-agent/agent-core-v2": "^0.1.0",
-    "@dimi-agent/dimi-telemetry": "^0.1.0",
+    "@dimi-agent/dimi-oauth": "^0.1.0",
     "@dimi-agent/dimi-sdk": "^0.2.0",
     "@dimi-agent/dimi-web": "^0.1.0",
+    "@dimi-agent/agent-core-v2": "^0.1.0",
+    "@dimi-agent/dimi-telemetry": "^0.1.0",
     "@dimi-agent/kap-server": "^0.1.0",
-    "@dimi-agent/dimi-oauth": "^0.1.0",
     "@dimi-agent/pi-tui": "^0.1.0",
     "@dimi-agent/remote": "^0.1.0"
   },