@dotdrelle/wiki-manager 0.8.2 → 0.10.4

package/src/shell/tui.tsx

@@ -7,10 +7,70 @@ import { LeftPane } from './LeftPane';
 import { RightPane } from './RightPane';
 import { SlashDialog } from './SlashDialog';
 import { SetupWizard } from './SetupWizard';
+import { StartupScreen, type StartupAction } from './StartupScreen';
 import { useSession } from './useSession';
+import { buildMcpStatus } from '../core/mcp.js';
+import { loadWikircProfile, summarizeWikircConfig } from '../core/wikirc.js';
+import { listWorkspaces } from '../core/workspaces.js';
 
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
+function emptyStartupInfo(version: string, workspace: { name: string } | null, workspaces: { name: string }[]) {
+  return {
+    version,
+    model: '',
+    connectedMcpServers: 0,
+    wikiReady: false,
+    workspaceName: workspace?.name ?? null,
+    profileName: 'default',
+    workspaces: workspaces.map((item) => item.name),
+    hasWorkspace: workspace != null,
+  };
+}
+
+function startupInfo(packageJson: Record<string, unknown>) {
+  // listWorkspaces() order is filesystem-dependent (readdirSync), not stable —
+  // sort so "the default workspace" is deterministic across runs/platforms.
+  const workspaces = [...listWorkspaces()].sort((a, b) => a.name.localeCompare(b.name));
+  const workspace = workspaces[0] ?? null;
+  const version = String(packageJson.version ?? '');
+  if (!workspace) return emptyStartupInfo(version, null, []);
+
+  try {
+    const loaded = loadWikircProfile(workspace.workspacePath, 'default');
+    const summary = summarizeWikircConfig(loaded.profile, loaded.config);
+    const session = {
+      workspace: workspace.name,
+      workspacePath: workspace.workspacePath,
+      workspaceEnv: workspace.env,
+      wikirc: {
+        profile: loaded.profile.name,
+        fileName: loaded.profile.fileName,
+        path: loaded.profile.path,
+      },
+      wikircConfig: loaded.config,
+    };
+    const mcp = buildMcpStatus(session);
+    const connectedMcpServers = Object.values(mcp)
+      .filter((server: any) => server?.status && server.status !== 'missing')
+      .length;
+    const provider = summary.provider ? String(summary.provider) : '';
+    const model = summary.model ? String(summary.model) : '';
+    return {
+      version,
+      model: [provider, model].filter(Boolean).join(' / '),
+      connectedMcpServers,
+      wikiReady: true,
+      workspaceName: workspace.name,
+      profileName: loaded.profile.name,
+      workspaces: workspaces.map((item) => item.name),
+      hasWorkspace: true,
+    };
+  } catch {
+    return emptyStartupInfo(version, workspace, workspaces);
+  }
+}
+
 function copyToClipboard(text: string, renderer: unknown) {
   try {
     if ((renderer as any).copyToClipboardOSC52?.(text)) return true;
@@ -49,11 +109,16 @@ function App(props: {
   const [exitHint, setExitHint] = createSignal(false);
   const [copyHint, setCopyHint] = createSignal<string | null>(null);
   const [chatInputHeight, setChatInputHeight] = createSignal(3);
+  // The app has exactly three mutually exclusive screens; one signal makes
+  // that invariant structural instead of relying on two booleans staying in
+  // sync at every call site.
+  const [screen, setScreen] = createSignal<'startup' | 'setup' | 'main'>('startup');
   let ctrlCTimer: ReturnType<typeof setTimeout> | null = null;
   let copyHintTimer: ReturnType<typeof setTimeout> | null = null;
   let selectionCopyTimer: ReturnType<typeof setTimeout> | null = null;
   let lastCopiedSelection = '';
   const state = useSession(props);
+  const startup = createMemo(() => startupInfo(props.packageJson));
   const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight()));
   const rightColumns = createMemo(() => {
     const width = dimensions().width;
@@ -73,6 +138,71 @@ function App(props: {
     });
   };
 
+  const loadWorkspace = async (workspaceName?: string | null) => {
+    if (!workspaceName) return false;
+    if ((state.session as any).workspace === workspaceName) return true;
+    await state.submitInput(`/use ${workspaceName}`);
+    // /use does not throw on failure (e.g. a stale/deleted workspace) — it
+    // just returns an error message without switching session.workspace, so
+    // callers must check the actual post-await state rather than assume success.
+    return (state.session as any).workspace === workspaceName;
+  };
+
+  // `startup` is a memo over non-reactive fs reads (listWorkspaces() etc.),
+  // so it only ever reflects state at first mount. Action handlers that
+  // decide *which* workspace to load must re-read current state directly
+  // (startupInfo(...)) rather than trust the frozen memo, the same way
+  // closeSetup() already does.
+  const loadDefaultWorkspace = async () => loadWorkspace(startupInfo(props.packageJson).workspaceName);
+
+  // "Open a workspace" is really one composite action (load it, then bring
+  // its services up) — named here so it has one definition instead of being
+  // inlined as three sequential submitInput calls in openAction.
+  const openWorkspaceAndStartServices = async (workspaceName?: string | null) => {
+    const loaded = await loadWorkspace(workspaceName);
+    if (loaded) {
+      await state.submitInput('/start agents');
+      await state.submitInput('/start all');
+    }
+    return loaded;
+  };
+
+  const openAction = (action: StartupAction, workspaceName?: string) => {
+    if (action === 'init-workspace') {
+      setScreen('setup');
+      return;
+    }
+    setScreen('main');
+    void (async () => {
+      try {
+        if (action === 'open-workspace') {
+          await openWorkspaceAndStartServices(workspaceName ?? startupInfo(props.packageJson).workspaceName);
+        } else if (action === 'new-conversation' || action === 'run-workflow') {
+          const loaded = await loadDefaultWorkspace();
+          if (action === 'run-workflow' && loaded) {
+            await state.submitInput('/agent');
+          }
+        }
+      } catch {
+        // Individual submitInput failures already surface their own error
+        // text in the conversation transcript; just stop the sequence here
+        // instead of leaving an unhandled rejection.
+      }
+    })();
+  };
+
+  const closeSetup = () => {
+    const info = startupInfo(props.packageJson);
+    if (!info.hasWorkspace) {
+      setScreen('startup');
+      return;
+    }
+    setScreen('main');
+    // Reuse loadWorkspace (not a bare /use dispatch) so the "already on this
+    // workspace" short-circuit applies here too.
+    void loadWorkspace(info.workspaceName);
+  };
+
   const showCopyHint = (message: string) => {
     setCopyHint(message);
     if (copyHintTimer) clearTimeout(copyHintTimer);
@@ -106,6 +236,7 @@ function App(props: {
 
   useKeyboard((key) => {
     const keyName = String(key.name ?? '').toLowerCase();
+    if (screen() !== 'main') return;
     if (state.activeEditor()) {
       if (keyName === 'escape') state.closeEditor();
       return;
@@ -151,6 +282,26 @@ function App(props: {
     return null;
   };
 
+  if (screen() === 'startup') {
+    const info = startup();
+    return (
+      <StartupScreen
+        version={info.version}
+        model={info.model}
+        connectedMcpServers={info.connectedMcpServers}
+        wikiReady={info.wikiReady}
+        workspaceName={info.workspaceName}
+        profileName={info.profileName}
+        workspaces={info.workspaces}
+        hasWorkspace={info.hasWorkspace}
+        width={dimensions().width}
+        height={dimensions().height}
+        onSelect={openAction}
+        onQuit={() => renderer.destroy()}
+      />
+    );
+  }
+
   return (
     <box width="100%" height="100%" flexDirection="row">
       <LeftPane
@@ -198,6 +349,18 @@ function App(props: {
         onSave={state.saveEditor}
         onCancel={state.closeEditor}
       />
+      {screen() === 'setup' ? (
+        <SetupWizard
+          mode="setup"
+          session={state.session}
+          width={dimensions().width}
+          height={dimensions().height}
+          initialRoute="workspace-name"
+          closeOnDone
+          onComplete={closeSetup}
+          onClose={closeSetup}
+        />
+      ) : null}
     </box>
   );
 }

package/src/shell/useAgent.ts

@@ -1,6 +1,6 @@
 import { createSignal } from 'solid-js';
-import { postRuntimeCancel, postRuntimeRun } from '../runtime/client.js';
-import { conversationMessages, runLine } from './repl.js';
+import { postRuntimeCancel } from '../runtime/client.js';
+import { conversationMessages, runLine, submitRuntimeRun } from './repl.js';
 
 export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
   const [busy, setBusy] = createSignal(false);
@@ -19,14 +19,22 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
 
     try {
       if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/')) {
-        await postRuntimeRun(trimmed, {
-          url: props.runtimeUrl,
-          workspace: props.session.workspace ?? null,
-        });
         conversationMessages(props.session).push({ role: 'user', content: trimmed });
-        conversationMessages(props.session).push({ role: 'command', content: `Runtime run queued: ${props.runtimeUrl}` });
-        props.onRuntimeAccepted?.();
-        props.addLog('runtime: run accepted');
+        const outcome = await submitRuntimeRun(trimmed, {
+          runtime: { url: props.runtimeUrl },
+          session: props.session,
+        });
+        if (outcome.kind === 'accepted') {
+          conversationMessages(props.session).push({ role: 'command', content: `Runtime run queued: ${props.runtimeUrl}` });
+          props.onRuntimeAccepted?.();
+          props.addLog('runtime: run accepted');
+        } else if (outcome.kind === 'queued') {
+          conversationMessages(props.session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+          props.addLog('runtime: control queued');
+        } else {
+          conversationMessages(props.session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
+          props.addLog(`runtime error: ${outcome.message}`);
+        }
         props.refresh();
         return { exit: false, runtime: true };
       }

package/src/shell/useSession.ts

@@ -169,6 +169,18 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   let lastVisiblePlan: Array<{ step: number; description: string; status: string }> | null = null;
   const activities = createMemo(() => {
     version();
+    const workflowActivities = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'activity'));
+    if (workflowActivities) {
+      return workflowActivities.map((node: any) => ({
+        ...(node.raw ?? {}),
+        key: node.key,
+        label: node.label,
+        status: node.status,
+        terminal: ['done', 'failed', 'cancelled'].includes(String(node.status)),
+        _runtime: true,
+        _workflow: true,
+      }));
+    }
     const runtimeActivities = nonEmptyRuntimeArray(runtimeState()?.activities);
     if (runtimeActivities) {
       return runtimeActivities.map((activity: any) => ({ ...activity, _runtime: true }));
@@ -184,6 +196,10 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   });
   const queueItems = createMemo(() => {
     version();
+    const workflowQueue = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue'));
+    if (workflowQueue) {
+      return workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }));
+    }
     const runtimeQueue = nonEmptyRuntimeArray(runtimeState()?.queue);
     if (runtimeQueue) return runtimeQueue.map((item: any) => ({ ...item, _runtime: true }));
     return projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
@@ -191,6 +207,14 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   });
   const queueInfo = createMemo(() => {
     version();
+    const workflowQueue = runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue');
+    if (Array.isArray(workflowQueue)) {
+      return {
+        active: workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        frozen: 0,
+      };
+    }
     const runtimeQueue = runtimeState()?.queue;
     if (Array.isArray(runtimeQueue)) {
       return {
@@ -203,6 +227,16 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   });
   const plan = createMemo(() => {
     version();
+    const workflowTasks = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'task'));
+    if (workflowTasks) {
+      return workflowTasks
+        .sort((a: any, b: any) => Number(a.step ?? 0) - Number(b.step ?? 0))
+        .map((node: any, index: number) => ({
+          step: Number(node.step ?? index + 1),
+          description: String(node.description ?? node.label ?? `Step ${index + 1}`),
+          status: String(node.status ?? 'pending'),
+        }));
+    }
     const runtimePlan = nonEmptyRuntimeArray(runtimeState()?.plan);
     if (runtimePlan) {
       return runtimePlan.map((step: any, index: number) => ({