march-cli 0.1.38 → 0.1.40

package/src/cli/workspace/command.mjs

@@ -3,8 +3,6 @@ import { resolve } from "node:path";
 import { brightBlack } from "../tui/ui-theme.mjs";
 import { registerProject, listRegisteredProjects } from "../../workspace/project-registry.mjs";
 import { buildWorkspaceSessionSelectItems, listWorkspaceSessions, workspaceSessionSearchText } from "../../workspace/session-index.mjs";
-import { resumePiSessionById } from "../session/pi-session-switch-command.mjs";
-import { loadPiSessionTranscriptTurns } from "../../session/transcript.mjs";
 
 export const WORKSPACE_SLASH_COMMANDS = [
   {
@@ -19,9 +17,9 @@ export const WORKSPACE_SLASH_COMMANDS = [
     run: async (ctx, command) => writeLines(ctx.ui, await handleProjectCommand(command, ctx)),
   },
   {
-    metadata: [{ name: "switch", description: "Open cross-project session switcher" }],
-    match: (trimmed) => trimmed === "/switch" ? { parsed: { type: "switch" } } : null,
-    run: handleSwitchCommand,
+    metadata: [{ name: "session", description: "Open workspace session selector" }],
+    match: (trimmed) => trimmed === "/session" ? { parsed: { type: "session" } } : null,
+    run: handleSessionCommand,
   },
 ];
 
@@ -45,9 +43,9 @@ export async function handleProjectCommand(command, { stateRoot }) {
   return ["Registered projects:", ...projects.map((project) => `- ${project.displayName}  ${brightBlack(project.rootPath)}`)];
 }
 
-export async function handleSwitchCommand({ stateRoot, currentProjectId, projectMarchDir, runner, workspaceSupervisor, workspaceOutputRouter, ui }) {
+export async function handleSessionCommand({ stateRoot, currentProjectId, runner, workspaceSupervisor, workspaceOutputRouter, ui }) {
   if (!stateRoot) {
-    ui.writeln("Session switcher is not available: workspace registry is missing.");
+    ui.writeln("Session selector is not available: workspace registry is missing.");
     return { handled: true };
   }
   const projects = await listWorkspaceSessions({ stateRoot, currentProjectId });
@@ -59,7 +57,7 @@ export async function handleSwitchCommand({ stateRoot, currentProjectId, project
     return { handled: true };
   }
   if (!ui.selectList) {
-    ui.writeln("Session switcher is only available in TUI.");
+    ui.writeln("Session selector is only available in TUI.");
     return { handled: true };
   }
   const selectedIndex = Math.max(0, items.findIndex((item) => item.project.current && item.session?.id === currentSessionId));
@@ -82,7 +80,6 @@ export async function handleSwitchCommand({ stateRoot, currentProjectId, project
     }
     try {
       const { result } = await workspaceSupervisor.startNewWorkspaceSession(item.project);
-      ui.restoreTranscript?.([]);
       ui.writeln(`Created session: ${item.project.displayName} / ${result?.sessionId ?? "new session"}`);
       return { handled: true, refreshContextTokens: true, activeChanged: true };
     } catch (err) {
@@ -93,25 +90,15 @@ export async function handleSwitchCommand({ stateRoot, currentProjectId, project
   if (workspaceSupervisor) {
     try {
       await workspaceSupervisor.activateWorkspaceSession({ project: item.project, session: item.session });
-      restoreTranscriptFromSession(item.session, ui);
-      const replayed = ctxReplayBufferedOutput({ workspaceOutputRouter, projectId: item.project.projectId, sessionId: item.session.id });
-      ui.writeln(`Switched to session: ${item.project.displayName} / ${item.session.name || item.session.id}${replayed ? ` (${replayed} buffered events replayed)` : ""}`);
+      ctxRenderActiveSession({ workspaceOutputRouter, projectId: item.project.projectId, sessionId: item.session.id });
       return { handled: true, refreshContextTokens: true, activeChanged: true };
     } catch (err) {
       ui.writeln(`Error: ${err.message}`);
       return { handled: true };
     }
   }
-  if (!item.project.current) {
-    ui.writeln(`Project switch target indexed: ${item.project.displayName}`);
-    ui.writeln(brightBlack("Cross-project attach requires the workspace supervisor."));
-    return { handled: true };
-  }
-  const sessions = projects.find((project) => project.current)?.sessions ?? [];
-  const lines = await resumePiSessionById(item.session.id, { runner, sessions, projectMarchDir });
-  if (isResumeSuccess(lines)) restoreTranscriptFromSession(item.session, ui);
-  for (const line of lines) ui.writeln(line);
-  return { handled: true, refreshContextTokens: isResumeSuccess(lines) };
+  ui.writeln("Workspace session activation requires the workspace supervisor.");
+  return { handled: true };
 }
 
 function annotateWorkspaceItems(items, runtimeSummaries) {
@@ -124,24 +111,11 @@ function annotateWorkspaceItems(items, runtimeSummaries) {
   });
 }
 
-function ctxReplayBufferedOutput({ workspaceOutputRouter, projectId, sessionId }) {
-  return workspaceOutputRouter?.replayBufferedCalls?.(projectId, sessionId) ?? 0;
-}
-
-function restoreTranscriptFromSession(session, ui) {
-  if (typeof ui.restoreTranscript !== "function") return;
-  try {
-    ui.restoreTranscript(loadPiSessionTranscriptTurns(session.path));
-  } catch (err) {
-    ui.writeln(`Warning: failed to restore session transcript: ${err.message}`);
-  }
+function ctxRenderActiveSession({ workspaceOutputRouter, projectId, sessionId }) {
+  return workspaceOutputRouter?.getRenderEventCount?.(projectId, sessionId) ?? 0;
 }
 
 function writeLines(ui, lines) {
   for (const line of lines) ui.writeln(line);
   return { handled: true };
 }
-
-function isResumeSuccess(lines) {
-  return Array.isArray(lines) && lines.some((line) => String(line).startsWith("Resumed pi session:"));
-}

package/src/cli/workspace/output-router.mjs

@@ -1,4 +1,8 @@
-const BACKGROUND_METHODS_TO_BUFFER = new Set([
+import { createTuiTimelineRegistry } from "./tui-timeline.mjs";
+
+const PERSIST_FLUSH_METHODS = new Set(["turnEnd", "assistantReplyEnd", "toolEnd"]);
+
+const RENDER_METHODS = new Set([
   "turnStart",
   "turnEnd",
   "assistantReplyEnd",
@@ -6,28 +10,43 @@ const BACKGROUND_METHODS_TO_BUFFER = new Set([
   "thinkingStart",
   "thinkingDelta",
   "thinkingEnd",
+  "thinkingBlock",
   "toolStart",
   "toolEnd",
   "retryStart",
   "retryEnd",
   "status",
-  "debugLines",
   "recall",
-  "providerQuotaSnapshot",
   "editDiff",
+  "write",
   "writeln",
+  "clearOutput",
 ]);
 
-export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSessionId = null }) {
+export function createWorkspaceOutputRouter({
+  ui,
+  activeProjectId,
+  activeSessionId = null,
+  onPersistRenderTimeline = null,
+  persistDebounceMs,
+} = {}) {
   let active = routeKey(activeProjectId, activeSessionId);
-  const buffers = new Map();
+  const timelineRegistry = createTuiTimelineRegistry({
+    persistDebounceMs,
+    onPersistTimeline: (change) => onPersistRenderTimeline?.({ ...parseRouteKey(change.key), ...change }),
+  });
 
   return {
     setActiveProject(projectId) {
-      active = routeKey(projectId, null);
+      this.setActiveSession(projectId, null);
     },
-    setActiveSession(projectId, sessionId) {
-      active = routeKey(projectId, sessionId);
+    setActiveSession(projectId, sessionId, { renderTimeline = null } = {}) {
+      const next = routeKey(projectId, sessionId);
+      timelineRegistry.ensure(next, { events: renderTimeline });
+      if (next === active) return renderRoute(next);
+      timelineRegistry.flush(active, "session-switch");
+      active = next;
+      return renderRoute(next);
     },
     getActiveRouteKey() {
       return active;
@@ -46,8 +65,9 @@ export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSession
           if (typeof value !== "function") return value;
           return (...args) => {
             const key = routeKey(projectId, typeof getSessionId === "function" ? getSessionId() : sessionId);
-            if (isActiveRoute(key) || !BACKGROUND_METHODS_TO_BUFFER.has(prop)) return value.apply(ui, args);
-            bufferBackgroundCall(key, prop, args);
+            if (!RENDER_METHODS.has(prop)) return value.apply(ui, args);
+            recordRenderEvent(key, prop, args);
+            if (key === active) return value.apply(ui, args);
             return undefined;
           };
         },
@@ -60,41 +80,47 @@ export function createWorkspaceOutputRouter({ ui, activeProjectId, activeSession
         },
       });
     },
-    getBufferedCalls(projectId, sessionId = null) {
-      return [...(buffers.get(routeKey(projectId, sessionId)) ?? [])];
+    renderActiveSession() {
+      return renderRoute(active);
     },
-    getBufferedCallCount(projectId, sessionId = null) {
-      return buffers.get(routeKey(projectId, sessionId))?.length ?? 0;
+    getRenderEvents(projectId, sessionId = null) {
+      return timelineRegistry.getEvents(routeKey(projectId, sessionId));
     },
-    replayBufferedCalls(projectId, sessionId = null) {
+    getRenderBlocks(projectId, sessionId = null) {
+      return timelineRegistry.getBlocks(routeKey(projectId, sessionId));
+    },
+    setRenderEvents(projectId, sessionId = null, events = []) {
       const key = routeKey(projectId, sessionId);
-      const calls = buffers.get(key) ?? [];
-      buffers.delete(key);
-      for (const call of calls) replayBufferedCall(call);
-      return calls.length;
+      timelineRegistry.replaceEvents(key, events);
+    },
+    getRenderEventCount(projectId, sessionId = null) {
+      return timelineRegistry.getEventCount(routeKey(projectId, sessionId));
     },
-    clearBufferedCalls(projectId, sessionId = null) {
-      buffers.delete(routeKey(projectId, sessionId));
+    getRenderTimelineMetadata(projectId, sessionId = null) {
+      return timelineRegistry.getMetadata(routeKey(projectId, sessionId));
+    },
+    flushRenderTimeline(projectId, sessionId = null, reason = "manual") {
+      return timelineRegistry.flush(routeKey(projectId, sessionId), reason);
+    },
+    flushAllRenderTimelines(reason = "manual") {
+      return timelineRegistry.flushAll(reason);
     },
   };
 
-  function isActiveRoute(key) {
-    if (key === active) return true;
-    const current = parseRouteKey(active);
-    const candidate = parseRouteKey(key);
-    return current.sessionId == null && current.projectId === candidate.projectId;
-  }
-
-  function replayBufferedCall({ method, args }) {
-    const value = ui[method];
-    if (typeof value === "function") value.apply(ui, args);
+  function renderRoute(key) {
+    const timeline = timelineRegistry.ensure(key);
+    if (typeof ui.restoreTimelineBlocks !== "function") ui.clearOutput?.();
+    return timeline.replayTo(ui);
   }
 
-  function bufferBackgroundCall(key, method, args) {
-    const calls = buffers.get(key) ?? [];
-    calls.push({ method, args, at: Date.now() });
-    if (calls.length > 2000) calls.splice(0, calls.length - 2000);
-    buffers.set(key, calls);
+  function recordRenderEvent(key, method, args) {
+    if (method === "clearOutput") {
+      timelineRegistry.clear(key);
+      return;
+    }
+    const timeline = timelineRegistry.ensure(key);
+    timeline.apply(method, args);
+    if (PERSIST_FLUSH_METHODS.has(method)) timeline.flushPersist(method);
   }
 }
 

package/src/cli/workspace/project-runtime.mjs

@@ -8,6 +8,7 @@ import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-ma
 import { loadKeybindings } from "../input/keybindings.mjs";
 import { loadPromptTemplates } from "../input/prompt-templates.mjs";
 import { loadOrCreateProjectId } from "../../workspace/project-id.mjs";
+import { syncRuntimeSessionStateFromRunner } from "./runtime-session-state.mjs";
 
 export async function createWorkspaceProjectRuntime({
   project,
@@ -73,6 +74,7 @@ export async function createWorkspaceProjectRuntime({
     refreshStatusBar,
     onNotificationActivation,
   });
+  syncRuntimeSessionStateFromRunner(sessionState, runner, sessionsRoot);
 
   return {
     project,

package/src/cli/workspace/runtime-session-state.mjs

@@ -0,0 +1,9 @@
+import { join } from "node:path";
+
+export function syncRuntimeSessionStateFromRunner(sessionState, runner, sessionsRoot) {
+  const sessionId = runner?.getSessionStats?.()?.sessionId ?? null;
+  if (!sessionState || !sessionId) return null;
+  sessionState.sessionId = sessionId;
+  sessionState.sessionDir = sessionsRoot ? join(sessionsRoot, sessionId) : sessionState.sessionDir;
+  return sessionState;
+}

package/src/cli/workspace/tui-timeline-projection.mjs

@@ -0,0 +1,179 @@
+export function createTuiTimelineProjection() {
+  let blocks = [];
+  let openAssistantBlock = null;
+  let openThinkingBlock = null;
+  let openToolBlocks = [];
+  let nextBlockIndex = 1;
+
+  return {
+    apply(event) {
+      applyProjectionEvent(event);
+    },
+    rebuild(events) {
+      resetProjection();
+      for (const event of events) applyProjectionEvent(event);
+    },
+    clear() {
+      resetProjection();
+    },
+    getBlocks() {
+      return blocks.map((block) => structuredCloneSafe(block));
+    },
+    getMetadata() {
+      return {
+        blockCount: blocks.length,
+        openAssistant: Boolean(openAssistantBlock),
+        openThinking: Boolean(openThinkingBlock),
+        openToolCount: openToolBlocks.length,
+      };
+    },
+  };
+
+  function applyProjectionEvent(event) {
+    const [first, second, third] = event.args ?? [];
+    switch (event.method) {
+      case "turnStart":
+        closeAssistantBlock();
+        blocks.push(createBlock("turn", event.at, { phase: "start" }));
+        break;
+      case "turnEnd":
+        closeAssistantBlock(event.at);
+        closeThinkingBlock(event.at);
+        blocks.push(createBlock("turn", event.at, { phase: "end" }));
+        break;
+      case "textDelta":
+        ensureAssistantBlock(event.at).content += String(first ?? "");
+        touchBlock(openAssistantBlock, event.at);
+        break;
+      case "assistantReplyEnd":
+        closeAssistantBlock(event.at);
+        break;
+      case "thinkingStart":
+        closeThinkingBlock(event.at);
+        openThinkingBlock = createBlock("thinking", event.at, { content: "", closed: false });
+        blocks.push(openThinkingBlock);
+        break;
+      case "thinkingDelta":
+        ensureThinkingBlock(event.at).content += String(first ?? "");
+        touchBlock(openThinkingBlock, event.at);
+        break;
+      case "thinkingEnd":
+        ensureThinkingBlock(event.at).tokens = first ?? null;
+        closeThinkingBlock(event.at);
+        break;
+      case "thinkingBlock":
+        closeThinkingBlock(event.at);
+        blocks.push(createBlock("thinking", event.at, { tokens: first ?? null, content: String(second ?? ""), closed: true }));
+        break;
+      case "toolStart": {
+        closeAssistantBlock(event.at);
+        const block = createBlock("tool", event.at, { name: first ?? null, args: second ?? null, result: null, isError: false, closed: false });
+        blocks.push(block);
+        openToolBlocks.push(block);
+        break;
+      }
+      case "toolEnd": {
+        const block = popOpenToolBlock(first);
+        if (block) {
+          block.name ??= first ?? null;
+          block.isError = Boolean(second);
+          block.result = third ?? null;
+          block.closed = true;
+          touchBlock(block, event.at);
+        } else {
+          blocks.push(createBlock("tool", event.at, { name: first ?? null, isError: Boolean(second), result: third ?? null, closed: true }));
+        }
+        break;
+      }
+      case "write":
+      case "writeln":
+        closeAssistantBlock(event.at);
+        blocks.push(createBlock("output", event.at, { content: String(first ?? ""), newline: event.method === "writeln" }));
+        break;
+      case "status":
+        blocks.push(createBlock("status", event.at, { content: String(first ?? "") }));
+        break;
+      case "recall":
+        blocks.push(createBlock("recall", event.at, { hints: first?.hints ?? [] }));
+        break;
+      case "editDiff":
+        closeAssistantBlock(event.at);
+        blocks.push(createBlock("editDiff", event.at, { path: first ?? null, diffLines: second ?? [] }));
+        break;
+      case "retryStart":
+      case "retryEnd":
+        blocks.push(createBlock("retry", event.at, { method: event.method, payload: first ?? null }));
+        break;
+      default:
+        blocks.push(createBlock("event", event.at, { method: event.method, args: event.args ?? [] }));
+        break;
+    }
+  }
+
+  function ensureAssistantBlock(at) {
+    if (!openAssistantBlock) {
+      openAssistantBlock = createBlock("assistant", at, { content: "", closed: false });
+      blocks.push(openAssistantBlock);
+    }
+    return openAssistantBlock;
+  }
+
+  function closeAssistantBlock(at = null) {
+    if (!openAssistantBlock) return;
+    openAssistantBlock.closed = true;
+    touchBlock(openAssistantBlock, at);
+    openAssistantBlock = null;
+  }
+
+  function ensureThinkingBlock(at) {
+    if (!openThinkingBlock) {
+      openThinkingBlock = createBlock("thinking", at, { content: "", closed: false });
+      blocks.push(openThinkingBlock);
+    }
+    return openThinkingBlock;
+  }
+
+  function closeThinkingBlock(at = null) {
+    if (!openThinkingBlock) return;
+    openThinkingBlock.closed = true;
+    touchBlock(openThinkingBlock, at);
+    openThinkingBlock = null;
+  }
+
+  function popOpenToolBlock(name) {
+    if (openToolBlocks.length === 0) return null;
+    if (name == null) return openToolBlocks.pop();
+    const index = findLastIndex(openToolBlocks, (block) => block.name === name);
+    if (index < 0) return openToolBlocks.pop();
+    return openToolBlocks.splice(index, 1)[0];
+  }
+  function resetProjection() {
+    blocks = [];
+    openAssistantBlock = null;
+    openThinkingBlock = null;
+    openToolBlocks = [];
+    nextBlockIndex = 1;
+  }
+
+  function createBlock(type, at, fields = {}) {
+    const id = `${type}-${nextBlockIndex++}`;
+    return { id, type, createdAt: at ?? null, updatedAt: at ?? null, ...fields };
+  }
+}
+
+function touchBlock(block, at = null) {
+  if (!block || at == null) return;
+  block.updatedAt = at;
+}
+
+function findLastIndex(items, predicate) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    if (predicate(items[index], index)) return index;
+  }
+  return -1;
+}
+
+function structuredCloneSafe(value) {
+  if (typeof structuredClone === "function") return structuredClone(value);
+  return JSON.parse(JSON.stringify(value));
+}