@dotdrelle/wiki-manager 0.11.4 → 0.11.7

package/src/shell/useSession.ts

@@ -1,6 +1,6 @@
 import { writeFileSync } from 'node:fs';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
-import { createMemo, createSignal, onCleanup } from 'solid-js';
+import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
@@ -14,12 +14,13 @@ import {
   completionDescription,
   conversationMessages,
   createSession,
+  runtimeUnavailableAgentMessage,
 } from './repl.js';
 import { useAgent } from './useAgent';
 
-function runtimeStatusText(status: 'disabled' | 'connected' | 'disconnected', runStatus: string): string {
-  if (status === 'connected') return `runtime ${runStatus}`;
-  if (status === 'disconnected') return 'runtime offline';
+function runtimeStatusText(status: 'disabled' | 'connected' | 'disconnected', runStatus: string, reason: string | null, workspace: string | null): string {
+  if (status === 'connected') return `runtime: connected (${workspace ?? 'no workspace'}) ${runStatus}`;
+  if (status === 'disconnected') return reason ? `runtime: disconnected: ${reason}` : 'runtime offline';
   return 'runtime off';
 }
 
@@ -74,13 +75,21 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   const addLog = (line: string) => {
     setLogs((items) => [...items, `${new Date().toLocaleTimeString()} ${line}`].slice(-200));
   };
+  const runtimeUnavailableReason = createMemo(() => {
+    if (props.runtime?.url) return null;
+    const reason = props.runtime?.error ?? props.runtime?.unavailableReason ?? props.runtime?.reason ?? null;
+    return reason ? String(reason) : null;
+  });
   if (props.runtime?.url) addLog(`runtime: connected ${props.runtime.url}${props.runtime.started ? ' (started)' : ''}`);
+  else if (props.runtime?.error) addLog(`runtime: unavailable — ${props.runtime.error}`);
+  else if (runtimeUnavailableReason()) addLog(`runtime: disconnected: ${runtimeUnavailableReason()}`);
   const agent = useAgent({
     agent: props.agent,
     packageJson: props.packageJson,
     session,
     chatMode,
     runtimeUrl: props.runtime?.url ?? null,
+    runtimeUnavailableReason: runtimeUnavailableReason(),
     refresh,
     addLog,
     onRuntimeAccepted: () => {
@@ -97,23 +106,22 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   );
   const localFallbackActive = createMemo(() => !props.runtime?.url || runtimeStatus() === 'disconnected');
 
+  // Runtime conversation entries are merged into conversationMessages(session)
+  // (see mergeRuntimeConversation below) as they arrive, so they land in true
+  // chronological order alongside local command output (/status, /use, ...)
+  // instead of being reconstructed as two separately-ordered blocks at render
+  // time — that used to put every local command before the whole runtime
+  // history regardless of when each one actually happened.
   const messages = createMemo(() => {
     version();
+    return [...conversationMessages(session)].slice(-200);
+  });
+  createEffect(() => {
     const runtimeConversation = runtimeState()?.conversation;
-    const localCommands = conversationMessages(session)
-      .filter((message: any) => message.role === 'command')
-      .map((message: any) => ({
-        role: 'command',
-        content: String(message.content ?? ''),
-      }));
     if (Array.isArray(runtimeConversation) && runtimeConversation.length > 0) {
-      const runtimeMessages = runtimeConversation.map((message: any) => ({
-        role: message.role === 'assistant' ? 'donna' : message.role,
-        content: String(message.content ?? ''),
-      }));
-      return [...runtimeMessages, ...localCommands].slice(-200);
+      setShowWelcome(false);
+      setConversationScroll(0);
     }
-    return [...conversationMessages(session)];
   });
   const prompt = createMemo(() => {
     version();
@@ -133,9 +141,14 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
       session.language ? session.language : 'no language',
       session.llm ? 'llm ready' : 'llm limited',
-      runtimeStatusText(runtimeStatus(), runtimeRunStatus()),
+      runtimeStatusText(runtimeStatus(), runtimeRunStatus(), runtimeUnavailableReason(), session.workspace),
     ].join('  ');
   });
+  const runtimeHint = createMemo(() => {
+    version();
+    if (props.runtime?.url) return null;
+    return runtimeUnavailableAgentMessage({ error: runtimeUnavailableReason() ?? 'runtime introuvable' });
+  });
   const matchContext = createMemo(() => {
     if (input() === dismissedSlashInput()) return null;
     return completionContext(input(), session);
@@ -263,10 +276,54 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     return [...logs(), ...tagged].slice(-200);
   });
 
+  // Index-aligned with each workspace's runtimeConversation array — not just
+  // a length count. The server sometimes finalizes a streaming placeholder
+  // (queued during a tool-calling turn, never closed out because that turn's
+  // reply had no final text) by overwriting the *same* conversation entry's
+  // content on a later turn, without the array growing. A length-based diff
+  // would miss that update entirely and leave the stale placeholder text
+  // shown forever; tracking local entry references per index picks it up.
+  const runtimeConversationRefsByWorkspace = new Map<string, any[]>();
+  function mergeRuntimeConversation(state: any) {
+    const workspace = (session as any).workspace || '__global__';
+    const runtimeConversation = Array.isArray(state?.conversation) ? state.conversation : [];
+    if (runtimeConversation.length === 0) return;
+    const target = conversationMessages(session);
+    const backed = runtimeConversationRefsByWorkspace.get(workspace) ?? [];
+    runtimeConversationRefsByWorkspace.set(workspace, backed);
+    for (let i = 0; i < runtimeConversation.length; i += 1) {
+      const message = runtimeConversation[i];
+      const content = String(message.content ?? '');
+      const role = message.role === 'assistant' ? 'donna' : message.role;
+      if (i < backed.length) {
+        const entry = backed[i];
+        if (entry.content !== content) entry.content = content;
+        if (entry.role !== role) entry.role = role;
+        continue;
+      }
+      if (role === 'user') {
+        // The user's own message was already pushed optimistically (see
+        // useAgent.ts) and marked _pending — confirm that entry instead of
+        // adding a second copy. No matching pending entry (e.g. history
+        // restored after a fresh reconnect) falls through to a normal push.
+        const pendingIndex = target.findIndex((entry: any) => entry._pending && entry.role === 'user' && entry.content === content);
+        if (pendingIndex !== -1) {
+          delete target[pendingIndex]._pending;
+          backed.push(target[pendingIndex]);
+          continue;
+        }
+      }
+      const entry = { role, content };
+      target.push(entry);
+      backed.push(entry);
+    }
+  }
+
   function syncRuntimeState() {
     void fetchRuntimeState({ url: props.runtime.url, workspace: (session as any).workspace ?? null })
       .then((state) => {
         setRuntimeState(state);
+        mergeRuntimeConversation(state);
         setRuntimeStatus('connected');
         refresh();
       })
@@ -310,6 +367,22 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     syncRuntimeState();
     void subscribeRuntimeEvents();
   }
+
+  let currentRuntimeWorkspace = (session as any).workspace ?? null;
+  function resyncRuntimeWorkspaceIfChanged() {
+    const workspace = (session as any).workspace ?? null;
+    if (workspace === currentRuntimeWorkspace) return;
+    currentRuntimeWorkspace = workspace;
+    if (!props.runtime?.url) return;
+    if (runtimeReconnectTimer) {
+      clearTimeout(runtimeReconnectTimer);
+      runtimeReconnectTimer = null;
+    }
+    runtimeStreamAbort?.abort();
+    syncRuntimeState();
+    void subscribeRuntimeEvents();
+  }
+
   onCleanup(() => {
     runtimeStreamStopped = true;
     runtimeStreamAbort?.abort();
@@ -408,6 +481,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     lastActivityLines.clear();
     lastActivityDetails.clear();
     const result = await agent.submit(line);
+    resyncRuntimeWorkspaceIfChanged();
     if ((result as any)?.setMode === 'chat') {
       setChatMode(true);
       (session as any).chatMode = true;
@@ -523,6 +597,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     setInput: updateInput,
     title,
     statusLine,
+    runtimeHint,
     chatMode,
     showWelcome,
     activeEditor,