@dotdrelle/wiki-manager 0.6.17

package/src/agent/llm.js

@@ -0,0 +1,239 @@
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, '');
+}
+
+function createStreamYieldController() {
+  let eventsSinceYield = 0;
+  let lastYieldAt = Date.now();
+  return async function yieldIfNeeded(force = false) {
+    eventsSinceYield += 1;
+    const now = Date.now();
+    if (!force && eventsSinceYield < 4 && now - lastYieldAt < 12) return;
+    eventsSinceYield = 0;
+    lastYieldAt = now;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  };
+}
+
+export function createLlmClientFromWikiConfig(config) {
+  const llmConfig = config?.llm;
+  const apiKey = llmConfig?.apiKey;
+  const model = llmConfig?.model;
+  const baseUrl = llmConfig?.baseUrl ? trimTrailingSlash(llmConfig.baseUrl) : undefined;
+
+  if (!apiKey || !model || !baseUrl) {
+    return null;
+  }
+
+  return {
+    async complete({ system, input }) {
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model,
+          messages: [
+            { role: 'system', content: system },
+            { role: 'user', content: input },
+          ],
+          temperature: typeof llmConfig.temperature === 'number' ? llmConfig.temperature : 0.2,
+        }),
+      });
+
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`HTTP ${response.status} ${body.slice(0, 240)}`);
+      }
+
+      const data = await response.json();
+      const content = data?.choices?.[0]?.message?.content;
+      if (!content || typeof content !== 'string') {
+        throw new Error('reponse LLM sans contenu texte');
+      }
+      return content;
+    },
+    async completeWithTools({ system, tools = [], messages = [], signal }) {
+      const allMessages = [
+        { role: 'system', content: system },
+        ...messages,
+      ];
+      const body = {
+        model,
+        messages: allMessages,
+        temperature: typeof llmConfig.temperature === 'number' ? llmConfig.temperature : 0.2,
+      };
+      if (tools.length > 0) {
+        body.tools = tools;
+        body.tool_choice = 'auto';
+      }
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        signal,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status} ${text.slice(0, 240)}`);
+      }
+      const data = await response.json();
+      const msg = data?.choices?.[0]?.message;
+      return {
+        content: msg?.content ?? null,
+        tool_calls: msg?.tool_calls?.length > 0 ? msg.tool_calls : null,
+        message: { role: 'assistant', content: msg?.content ?? null, tool_calls: msg?.tool_calls },
+      };
+    },
+    async streamWithTools({ system, tools = [], messages = [], onTextDelta, signal }) {
+      const allMessages = [
+        { role: 'system', content: system },
+        ...messages,
+      ];
+      const body = {
+        model,
+        messages: allMessages,
+        temperature: typeof llmConfig.temperature === 'number' ? llmConfig.temperature : 0.2,
+        stream: true,
+      };
+      if (tools.length > 0) {
+        body.tools = tools;
+        body.tool_choice = 'auto';
+      }
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        signal,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status} ${text.slice(0, 240)}`);
+      }
+      if (!response.body) {
+        const result = await this.completeWithTools({ system, tools, messages, signal });
+        if (result.content) onTextDelta?.(result.content);
+        return result;
+      }
+      const toolCallsMap = {};
+      let textContent = '';
+      const decoder = new TextDecoder();
+      let buffer = '';
+      const yieldForRender = createStreamYieldController();
+      for await (const chunk of response.body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        let chunkHadContent = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith('data:')) continue;
+          const data = trimmed.slice('data:'.length).trim();
+          if (!data || data === '[DONE]') continue;
+          let parsed;
+          try { parsed = JSON.parse(data); } catch { continue; }
+          const delta = parsed?.choices?.[0]?.delta;
+          if (!delta) continue;
+          if (typeof delta.content === 'string' && delta.content) {
+            textContent += delta.content;
+            onTextDelta?.(delta.content);
+            chunkHadContent = true;
+            await yieldForRender();
+          }
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index ?? 0;
+              if (!toolCallsMap[idx]) {
+                toolCallsMap[idx] = { id: '', type: 'function', function: { name: '', arguments: '' } };
+              }
+              if (tc.id) toolCallsMap[idx].id = tc.id;
+              if (tc.type) toolCallsMap[idx].type = tc.type;
+              if (tc.function?.name) toolCallsMap[idx].function.name += tc.function.name;
+              if (tc.function?.arguments) toolCallsMap[idx].function.arguments += tc.function.arguments;
+            }
+          }
+        }
+        // Yield to the macro-task queue after each chunk that produced text so
+        // OpenTUI's render loop (setInterval at 30 fps) can fire between bursts.
+        if (chunkHadContent) await yieldForRender(true);
+      }
+      const toolCalls = Object.keys(toolCallsMap)
+        .sort((a, b) => Number(a) - Number(b))
+        .map((idx) => toolCallsMap[idx]);
+      const message = {
+        role: 'assistant',
+        content: textContent || null,
+        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+      };
+      return {
+        content: textContent || null,
+        tool_calls: toolCalls.length > 0 ? toolCalls : null,
+        message,
+      };
+    },
+    async *stream({ system, messages = [], signal }) {
+      const allMessages = [
+        { role: 'system', content: system },
+        ...messages,
+      ];
+      const response = await fetch(`${baseUrl}/chat/completions`, {
+        method: 'POST',
+        signal,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          model,
+          messages: allMessages,
+          temperature: typeof llmConfig.temperature === 'number' ? llmConfig.temperature : 0.2,
+          stream: true,
+        }),
+      });
+
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`HTTP ${response.status} ${body.slice(0, 240)}`);
+      }
+
+      if (!response.body) {
+        const fallback = await this.completeWithTools({ system, messages });
+        yield fallback.content ?? '';
+        return;
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = '';
+      const yieldForRender = createStreamYieldController();
+      for await (const chunk of response.body) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+        let chunkHadContent = false;
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith('data:')) continue;
+          const data = trimmed.slice('data:'.length).trim();
+          if (!data || data === '[DONE]') continue;
+          let parsed;
+          try { parsed = JSON.parse(data); } catch { continue; }
+          const delta = parsed?.choices?.[0]?.delta?.content;
+          if (typeof delta === 'string' && delta) {
+            yield delta;
+            chunkHadContent = true;
+            await yieldForRender();
+          }
+        }
+        if (chunkHadContent) await yieldForRender(true);
+      }
+    },
+  };
+}

package/src/cli/wiki-manager.js

@@ -0,0 +1,389 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadManagerEnv } from '../core/env.js';
+loadManagerEnv();
+import { createAgentGraph, buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
+import { handleSlashCommand, printHelp, printVersion } from '../commands/slash.js';
+import { runShell } from '../shell/repl.js';
+import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
+import { extractHeadlessPlan, syncActivitiesToPlan, formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = resolve(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspaces', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent'];
+
+function valueAfter(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) return undefined;
+  return argv[index + 1];
+}
+
+function createSession() {
+  return {
+    workspace: null,
+    workspacePath: null,
+    workspaceEnvFile: null,
+    wikirc: null,
+    wikircConfig: null,
+    language: null,
+    mcp: null,
+    commands: SHELL_COMMANDS,
+    chatMode: true,
+    llm: null,
+    packageJson,
+    conversations: { __global__: [] },
+    activities: {},
+    productionActivity: null,
+    headlessPlan: null,
+  };
+}
+
+function timestampForFile() {
+  return new Date().toISOString().replace(/[:.]/g, '-');
+}
+
+async function writeHeadlessLog(session, lines, explicitPath) {
+  const logPath = explicitPath
+    ? resolve(explicitPath)
+    : join(session.workspacePath ?? process.cwd(), '.wiki', 'logs', `headless-${timestampForFile()}.log`);
+  await mkdir(dirname(logPath), { recursive: true });
+  await writeFile(logPath, `${lines.join('\n')}\n`, 'utf8');
+  return logPath;
+}
+
+function activitySnapshot(session) {
+  return new Set(sessionActivities(session).map((a) => a.key));
+}
+
+function newNonTerminalActivities(snapshotBefore, session) {
+  return sessionActivities(session).filter((a) => !snapshotBefore.has(a.key) && !a.terminal);
+}
+
+function terminalFailures(activities) {
+  return activities.filter(
+    (a) => a.terminal && ['failed', 'error', 'cancelled', 'canceled'].includes(String(a.status).toLowerCase()),
+  );
+}
+
+
+async function runHeadlessActivityLoop(session, log, { wait, timeoutMs }) {
+  if (!wait) return { exitCode: 0, completed: [], timedOut: false };
+  const deadline = Date.now() + timeoutMs;
+  const pollBusy = new Set();
+  // Track which keys were non-terminal when we entered, so we can report them on exit.
+  const trackedKeys = new Set(sessionActivities(session).filter((a) => !a.terminal).map((a) => a.key));
+  log.push(`activity-loop: started, timeout=${Math.round(timeoutMs / 1000)}s`);
+  console.log(`[headless] Waiting for active jobs (timeout: ${Math.round(timeoutMs / 1000)}s)…`);
+
+  while (Date.now() < deadline) {
+    const candidates = sessionActivities(session).filter((a) => a.poll && !a.terminal);
+    if (candidates.length === 0) {
+      const completed = sessionActivities(session).filter((a) => trackedKeys.has(a.key));
+      const failures = terminalFailures(completed);
+      if (failures.length > 0) {
+        for (const a of failures) {
+          const line = `activity-loop: ${a.label} → ${a.status}${a.error ? ` — ${a.error}` : ''}`;
+          log.push(line);
+          console.error(`[headless] ${line}`);
+        }
+        return { exitCode: 1, completed, timedOut: false };
+      }
+      if (completed.length > 0) {
+        log.push('activity-loop: all activities terminal');
+        console.log('[headless] All jobs completed.');
+      }
+      return { exitCode: 0, completed, timedOut: false };
+    }
+
+    for (const activity of candidates) {
+      const key = activity.key ?? `${activity.poll.server}:${activity.id ?? 'activity'}`;
+      if (pollBusy.has(key)) continue;
+      const endpoint = session.mcp?.[activity.poll.server];
+      if (!endpoint || endpoint.status !== 'connected') {
+        const line = `activity-loop: MCP server '${activity.poll.server}' not connected — cannot poll ${key}`;
+        log.push(line);
+        console.error(`[headless] ${line}`);
+        const completed = sessionActivities(session).filter((a) => trackedKeys.has(a.key));
+        return { exitCode: 1, completed, timedOut: false };
+      }
+      const intervalMs = activity.poll.intervalMs ?? 2500;
+      if (Date.now() - Date.parse(activity.lastPolledAt ?? '0') < intervalMs) continue;
+      pollBusy.add(key);
+      activity.lastPolledAt = new Date().toISOString();
+      try {
+        const result = await callMcpTool(session.mcp, activity.poll.server, activity.poll.tool, activity.poll.args ?? {});
+        const payload = parseJsonText(formatMcpToolResult(result));
+        const polledActivity = extractActivity(payload, { server: activity.poll.server, tool: activity.poll.tool });
+        if (polledActivity) {
+          dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+            origin: 'poll',
+            payload: { activity: polledActivity },
+          }));
+        } else {
+          syncActivitiesToPlan(session.headlessPlan, sessionActivities(session));
+        }
+        const updated = sessionActivities(session).find((a) => a.key === key);
+        if (updated) {
+          const line = `activity-loop: ${updated.label} → ${updated.status}${updated.error ? ` — ${updated.error}` : ''}`;
+          log.push(line);
+          console.log(`[headless] ${line}`);
+        }
+      } catch (err) {
+        log.push(`activity-loop: poll error ${key} — ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        pollBusy.delete(key);
+      }
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  const completed = sessionActivities(session).filter((a) => trackedKeys.has(a.key));
+  log.push('activity-loop: timeout');
+  console.error('[headless] Timeout waiting for activities to complete.');
+  return { exitCode: 1, completed, timedOut: true };
+}
+
+async function runHeadlessAgentTurn(agent, session, input, log, messages = []) {
+  session.packageJson = packageJson;
+  let streamedContent = '';
+  session._onStream = (delta) => { streamedContent += delta; };
+  session._onStreamReset = () => { streamedContent = ''; };
+  let result;
+  try {
+    result = await agent.invoke({ input, session, messages });
+  } finally {
+    delete session._onStream;
+    delete session._onStreamReset;
+  }
+  if (result.streamedInline) {
+    return streamedContent.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  if (result.response != null) return result.response;
+  if (result.readyToStream && session.llm?.stream) {
+    const { system, messages: streamMessages = [] } = result.streamContext ?? {};
+    let content = '';
+    for await (const delta of session.llm.stream({
+      system: system ?? buildAgentSystemPrompt({ input, session }),
+      messages: streamMessages,
+    })) {
+      content += delta;
+    }
+    return content.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  return buildLimitedAgentResponse({ input, session });
+}
+
+async function runHeadlessAgenticLoop(agent, session, initialInput, log, { timeoutMs, maxTurns }) {
+  const conversationHistory = [];
+  let currentInput = initialInput;
+
+  for (let turn = 1; turn <= maxTurns; turn++) {
+    log.push(`agentic-loop: turn ${turn}/${maxTurns}`);
+    console.log(`[headless] Agent turn ${turn}/${maxTurns}…`);
+
+    const snapshot = activitySnapshot(session);
+
+    const response = await runHeadlessAgentTurn(agent, session, currentInput, log, conversationHistory);
+    log.push(`agentic-loop: turn ${turn} response:`);
+    log.push(response);
+    console.log(response);
+
+    conversationHistory.push(
+      { role: 'user', content: currentInput },
+      { role: 'assistant', content: response },
+    );
+
+    // session.headlessPlan is set authoritatively by wiki__plan_set tool call.
+    // Fall back to text extraction only if the agent didn't call the tool.
+    if (turn === 1 && session.headlessPlan === null) {
+      const extractedPlan = extractHeadlessPlan(response);
+      if (extractedPlan) {
+        dispatchAgentEvent(session, createAgentEvent('plan_set', {
+          origin: 'llm',
+          payload: { steps: extractedPlan },
+        }));
+        log.push(`agentic-loop: plan extracted from text (${session.headlessPlan.length} steps, fallback)`);
+      }
+    } else if (turn === 1 && session.headlessPlan) {
+      log.push(`agentic-loop: plan set via tool (${session.headlessPlan.length} steps)`);
+    }
+
+    const newPending = newNonTerminalActivities(snapshot, session);
+    if (newPending.length === 0) {
+      const pendingSteps = (session.headlessPlan ?? []).filter((s) => s.status === 'pending');
+      if (pendingSteps.length === 0) {
+        log.push('agentic-loop: no new non-terminal activities — plan complete');
+        console.log('[headless] Plan complete.');
+        return { exitCode: 0 };
+      }
+      log.push(`agentic-loop: no new async activity, ${pendingSteps.length} pending step(s) remain`);
+      if (session.headlessPlan) log.push(`agentic-loop: plan status:\n${formatPlanStatus(session.headlessPlan)}`);
+      currentInput = [
+        'Original task:',
+        initialInput,
+        '',
+        `Plan status:\n${formatPlanStatus(session.headlessPlan)}`,
+        '',
+        'No new background activity was started in the previous turn.',
+        'Continue the original plan. Start the next pending step only.',
+        'If required information is missing and cannot be inferred, stop with a clear blocker.',
+      ].join('\n');
+      continue;
+    }
+
+    log.push(`agentic-loop: ${newPending.length} new job(s) started, waiting…`);
+    const { exitCode, completed, timedOut } = await runHeadlessActivityLoop(session, log, { wait: true, timeoutMs });
+
+    if (timedOut || exitCode !== 0) return { exitCode };
+
+    const summary = formatCompletedActivities(completed);
+    log.push(`agentic-loop: completed activities:\n${summary}`);
+    if (session.headlessPlan) log.push(`agentic-loop: plan status:\n${formatPlanStatus(session.headlessPlan)}`);
+    currentInput = [
+      'Original task:',
+      initialInput,
+      '',
+      session.headlessPlan ? `Plan status:\n${formatPlanStatus(session.headlessPlan)}\n` : null,
+      'Completed activities:',
+      summary,
+      '',
+      'Continue the original plan. Start the next required step only.',
+      'If all steps are complete, provide the final summary.',
+    ].filter(Boolean).join('\n');
+  }
+
+  log.push(`agentic-loop: max turns (${maxTurns}) reached without completing`);
+  console.error(`[headless] Max agent turns (${maxTurns}) reached.`);
+  return { exitCode: 1 };
+}
+
+async function runHeadless(argv, agent) {
+  const workspaceName = valueAfter(argv, '--workspace');
+  const skillName = valueAfter(argv, '--skill');
+  const prompt = valueAfter(argv, '--prompt');
+  const logFile = valueAfter(argv, '--log-file');
+  const timeoutArg = valueAfter(argv, '--timeout');
+  const maxTurnsArg = valueAfter(argv, '--max-turns');
+  const timeoutMs = (Number.isFinite(Number(timeoutArg)) ? Math.max(1, Number(timeoutArg)) : 3600) * 1000;
+  const maxTurns = Number.isFinite(Number(maxTurnsArg)) ? Math.max(1, Number(maxTurnsArg)) : 20;
+  // --skill uses the agentic loop (multi-turn); --prompt uses a single turn unless --wait is set.
+  const useAgenticLoop = Boolean(skillName) && !argv.includes('--no-wait');
+  const wait = !useAgenticLoop && (argv.includes('--wait'));
+  const log = [`wiki-manager ${packageJson.version} headless`, `startedAt=${new Date().toISOString()}`];
+
+  if (!workspaceName) throw new Error('Usage: wiki-manager --headless --workspace <name> (--skill <name>|--prompt <text>)');
+  if (!skillName && !prompt) throw new Error('Usage: wiki-manager --headless --workspace <name> (--skill <name>|--prompt <text>)');
+
+  const session = createSession();
+  session.headless = true;
+  session.chatMode = false;
+  const step = (line) => {
+    log.push(line);
+    console.log(line);
+  };
+
+  try {
+    const useResult = await handleSlashCommand(`/use ${workspaceName}`, { packageJson, session, onStep: step });
+    if (useResult.output) log.push(useResult.output);
+    if (!session.workspacePath) throw new Error(useResult.output || `Workspace not loaded: ${workspaceName}`);
+    if (!session.llm) throw new Error(`Workspace ${workspaceName} has no usable LLM config.`);
+
+    let input = prompt;
+    if (skillName) {
+      const skillResult = await handleSlashCommand(`/skills run ${skillName}`, { packageJson, session, onStep: step });
+      if (skillResult.output) log.push(skillResult.output);
+      if (String(skillResult.output ?? '').startsWith('Skill not found')) throw new Error(`Skill not found: ${skillName}`);
+      input = skillResult.agentTrigger
+        ? [
+            skillResult.agentTrigger,
+            prompt ? `Additional instruction: ${prompt}` : null,
+          ].filter(Boolean).join('\n\n')
+        : [
+            `Run the ${skillName} skill for workspace ${workspaceName} in headless mode.`,
+            prompt ? `Additional instruction: ${prompt}` : null,
+            '',
+            skillResult.output,
+          ].filter(Boolean).join('\n');
+    }
+
+    log.push(`input=${input}`);
+    dispatchAgentEvent(session, createAgentEvent('run_started', {
+      origin: 'user',
+      payload: { input },
+    }));
+    dispatchAgentEvent(session, createAgentEvent('user_message', {
+      origin: 'user',
+      payload: { content: input },
+    }));
+    let exitCode = 0;
+    if (useAgenticLoop) {
+      ({ exitCode } = await runHeadlessAgenticLoop(agent, session, input, log, { timeoutMs, maxTurns }));
+    } else {
+      const response = await runHeadlessAgentTurn(agent, session, input, log);
+      log.push('response:');
+      log.push(response);
+      console.log(response);
+      ({ exitCode } = await runHeadlessActivityLoop(session, log, { wait, timeoutMs }));
+    }
+    const saved = await writeHeadlessLog(session, log, logFile);
+    console.log(`Headless log: ${saved}`);
+    if (exitCode !== 0) process.exitCode = exitCode;
+  } catch (err) {
+    log.push(`error=${err instanceof Error ? err.message : String(err)}`);
+    if (session.workspacePath || logFile) {
+      const saved = await writeHeadlessLog(session, log, logFile);
+      console.error(`Headless log: ${saved}`);
+    }
+    throw err;
+  }
+}
+
+export async function runCli(argv) {
+  if (argv.includes('--version') || argv.includes('-v')) {
+    printVersion(packageJson);
+    return;
+  }
+
+  if (argv.includes('--help') || argv.includes('-h')) {
+    printHelp(packageJson);
+    return;
+  }
+
+  const agent = createAgentGraph();
+  if (argv.includes('--headless')) {
+    try {
+      await runHeadless(argv, agent);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  const once = valueAfter(argv, '--once');
+  if (once) {
+    const result = await agent.invoke({
+      input: once,
+      session: createSession(),
+    });
+    console.log(result.response);
+    return;
+  }
+
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    if (!process.versions.bun) {
+      throw new Error('Interactive TUI requires Bun. Run: bun ./bin/wiki-manager.js');
+    }
+    const { runOpenTuiShell } = await import('../shell/tui.tsx');
+    await runOpenTuiShell({ agent, packageJson });
+    return;
+  }
+
+  await runShell({ agent, packageJson });
+}