@yeshwanthyk/coding-agent 0.3.12 → 0.3.14

package/dist/ui/app-shell/TuiApp.js

@@ -1,16 +1,15 @@
-import { jsx as _jsx, jsxs as _jsxs } from "solid-js/h/jsx-runtime";
+import { createComponent as _$createComponent } from "@opentui/solid";
 import { ThemeProvider } from "@yeshwanthyk/open-tui";
 import { batch, onMount } from "solid-js";
 import { Effect } from "effect";
 /** Detect system dark/light mode (macOS only, defaults to dark) */
 function detectThemeMode() {
-    try {
-        const result = Bun.spawnSync(["defaults", "read", "-g", "AppleInterfaceStyle"]);
-        return result.stdout.toString().trim().toLowerCase() === "dark" ? "dark" : "light";
-    }
-    catch {
-        return "dark";
-    }
+  try {
+    const result = Bun.spawnSync(["defaults", "read", "-g", "AppleInterfaceStyle"]);
+    return result.stdout.toString().trim().toLowerCase() === "dark" ? "dark" : "light";
+  } catch {
+    return "dark";
+  }
 }
 import { useRuntime } from "../../runtime/context.js";
 import { createSessionController } from "../../runtime/session/session-controller.js";
@@ -29,450 +28,600 @@ import { completeSimple } from "@yeshwanthyk/ai";
 import { useModals } from "../hooks/useModals.js";
 import { ModalContainer } from "../components/modals/ModalContainer.js";
 const SHELL_INJECTION_PREFIX = "[Shell output]";
-export const TuiApp = ({ initialSession }) => {
-    const runtime = useRuntime();
-    const { agent, sessionManager, hookRunner, toolByName, customCommands, lsp, config, codexTransport, getApiKey, sendRef, lspActiveRef, cycleModels, validationIssues, } = runtime;
-    const toolMetaByName = new Map();
-    for (const [name, entry] of toolByName.entries()) {
-        toolMetaByName.set(name, {
-            label: entry.label,
-            source: entry.source,
-            sourcePath: entry.sourcePath,
-            renderCall: entry.renderCall,
-            renderResult: entry.renderResult,
-        });
+export const TuiApp = ({
+  initialSession
+}) => {
+  const runtime = useRuntime();
+  const {
+    agent,
+    sessionManager,
+    hookRunner,
+    toolByName,
+    customCommands,
+    lsp,
+    config,
+    codexTransport,
+    getApiKey,
+    sendRef,
+    lspActiveRef,
+    cycleModels,
+    validationIssues
+  } = runtime;
+  const toolMetaByName = new Map();
+  for (const [name, entry] of toolByName.entries()) {
+    toolMetaByName.set(name, {
+      label: entry.label,
+      source: entry.source,
+      sourcePath: entry.sourcePath,
+      renderCall: entry.renderCall,
+      renderResult: entry.renderResult
+    });
+  }
+  const store = createAppStore({
+    initialTheme: config.theme,
+    initialModelId: config.modelId,
+    initialThinking: config.thinking,
+    initialContextWindow: config.model.contextWindow,
+    initialProvider: config.provider
+  });
+  const promptQueue = createPromptQueue(counts => store.queueCounts.set(counts));
+  const modals = useModals();
+  const sessionController = createSessionController({
+    initialProvider: config.provider,
+    initialModel: config.model,
+    initialModelId: config.modelId,
+    initialThinking: config.thinking,
+    agent,
+    sessionManager,
+    hookRunner,
+    toolByName: toolMetaByName,
+    setMessages: store.messages.set,
+    setContextTokens: store.contextTokens.set,
+    setDisplayProvider: store.currentProvider.set,
+    setDisplayModelId: store.displayModelId.set,
+    setDisplayThinking: store.displayThinking.set,
+    setDisplayContextWindow: store.displayContextWindow.set,
+    shellInjectionPrefix: SHELL_INJECTION_PREFIX,
+    promptQueue
+  });
+  onMount(() => {
+    if (initialSession) {
+      sessionController.restoreSession(initialSession);
     }
-    const store = createAppStore({
-        initialTheme: config.theme,
-        initialModelId: config.modelId,
-        initialThinking: config.thinking,
-        initialContextWindow: config.model.contextWindow,
-        initialProvider: config.provider,
+  });
+  const ensureSession = () => sessionController.ensureSession();
+  let cycleIndex = cycleModels.findIndex(entry => entry.model.id === config.modelId && entry.provider === config.provider);
+  if (cycleIndex < 0) cycleIndex = 0;
+  const streamingMessageIdRef = {
+    current: null
+  };
+  const retryConfig = {
+    enabled: true,
+    maxRetries: 3,
+    baseDelayMs: 2000
+  };
+  const retryablePattern = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error/i;
+  const retryState = {
+    attempt: 0,
+    abortController: null
+  };
+  lspActiveRef.setActive = store.lspActive.set;
+  const eventCtx = {
+    setMessages: store.messages.set,
+    setToolBlocks: store.toolBlocks.set,
+    setActivityState: store.activityState.set,
+    setIsResponding: store.isResponding.set,
+    setContextTokens: store.contextTokens.set,
+    setCacheStats: store.cacheStats.set,
+    setRetryStatus: store.retryStatus.set,
+    setTurnCount: store.turnCount.set,
+    promptQueue,
+    sessionManager,
+    streamingMessageId: streamingMessageIdRef,
+    retryConfig,
+    retryablePattern,
+    retryState,
+    agent: agent,
+    hookRunner,
+    toolByName: toolMetaByName,
+    getContextWindow: () => store.displayContextWindow.value()
+  };
+  useAgentEvents({
+    agent,
+    context: eventCtx
+  });
+  const handleThemeChange = name => {
+    store.theme.set(name);
+    void updateAppConfig({
+      configDir: config.configDir,
+      configPath: config.configPath
+    }, {
+      theme: name
     });
-    const promptQueue = createPromptQueue((counts) => store.queueCounts.set(counts));
-    const modals = useModals();
-    const sessionController = createSessionController({
-        initialProvider: config.provider,
-        initialModel: config.model,
-        initialModelId: config.modelId,
-        initialThinking: config.thinking,
-        agent,
-        sessionManager,
-        hookRunner,
-        toolByName: toolMetaByName,
-        setMessages: store.messages.set,
-        setContextTokens: store.contextTokens.set,
-        setDisplayProvider: store.currentProvider.set,
-        setDisplayModelId: store.displayModelId.set,
-        setDisplayThinking: store.displayThinking.set,
-        setDisplayContextWindow: store.displayContextWindow.set,
-        shellInjectionPrefix: SHELL_INJECTION_PREFIX,
-        promptQueue,
+  };
+  const exitHandlerRef = {
+    current: () => process.exit(0)
+  };
+  const editorOpenRef = {
+    current: async () => {}
+  };
+  const setEditorTextRef = {
+    current: _text => {}
+  };
+  const getEditorTextRef = {
+    current: () => ""
+  };
+  const showToastRef = {
+    current: (_title, _message, _variant) => {}
+  };
+  // Flag to skip editor clear when hooks populate the editor via setEditorText
+  const skipNextEditorClearRef = {
+    current: false
+  };
+  const handleBeforeExit = async () => {
+    // Emit shutdown hook before exiting
+    await hookRunner.emit({
+      type: "session.shutdown",
+      sessionId: sessionManager.sessionId
     });
-    onMount(() => {
-        if (initialSession) {
-            sessionController.restoreSession(initialSession);
-        }
+  };
+  const submitPrompt = async (text, mode = "followUp") => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    ensureSession();
+    let beforeStartResult;
+    try {
+      beforeStartResult = await hookRunner.emitBeforeAgentStart(trimmed);
+      const hookMsg = beforeStartResult?.message ? createHookMessage(beforeStartResult.message) : null;
+      if (hookMsg?.display) {
+        const uiMsg = {
+          id: crypto.randomUUID(),
+          role: "assistant",
+          content: typeof hookMsg.content === "string" ? hookMsg.content : hookMsg.content.map(p => p.type === "text" ? p.text : "[image]").join(""),
+          timestamp: hookMsg.timestamp
+        };
+        store.messages.set(prev => appendWithCap(prev, uiMsg));
+      }
+    } catch (err) {
+      store.messages.set(prev => appendWithCap(prev, {
+        id: crypto.randomUUID(),
+        role: "assistant",
+        content: `Hook error: ${err instanceof Error ? err.message : String(err)}`,
+        timestamp: Date.now()
+      }));
+    }
+    promptQueue.push({
+      text: trimmed,
+      mode
     });
-    const ensureSession = () => sessionController.ensureSession();
-    let cycleIndex = cycleModels.findIndex((entry) => entry.model.id === config.modelId && entry.provider === config.provider);
-    if (cycleIndex < 0)
-        cycleIndex = 0;
-    const streamingMessageIdRef = { current: null };
-    const retryConfig = { enabled: true, maxRetries: 3, baseDelayMs: 2000 };
-    const retryablePattern = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error/i;
-    const retryState = { attempt: 0, abortController: null };
-    lspActiveRef.setActive = store.lspActive.set;
-    const eventCtx = {
-        setMessages: store.messages.set,
-        setToolBlocks: store.toolBlocks.set,
-        setActivityState: store.activityState.set,
-        setIsResponding: store.isResponding.set,
-        setContextTokens: store.contextTokens.set,
-        setCacheStats: store.cacheStats.set,
-        setRetryStatus: store.retryStatus.set,
-        setTurnCount: store.turnCount.set,
-        promptQueue,
-        sessionManager,
-        streamingMessageId: streamingMessageIdRef,
-        retryConfig,
-        retryablePattern,
-        retryState,
-        agent: agent,
-        hookRunner,
-        toolByName: toolMetaByName,
-        getContextWindow: () => store.displayContextWindow.value(),
-    };
-    useAgentEvents({ agent, context: eventCtx });
-    const handleThemeChange = (name) => {
-        store.theme.set(name);
-        void updateAppConfig({ configDir: config.configDir, configPath: config.configPath }, { theme: name });
-    };
-    const exitHandlerRef = { current: () => process.exit(0) };
-    const editorOpenRef = { current: async () => { } };
-    const setEditorTextRef = { current: (_text) => { } };
-    const getEditorTextRef = { current: () => "" };
-    const showToastRef = { current: (_title, _message, _variant) => { } };
-    // Flag to skip editor clear when hooks populate the editor via setEditorText
-    const skipNextEditorClearRef = { current: false };
-    const handleBeforeExit = async () => {
-        // Emit shutdown hook before exiting
-        await hookRunner.emit({ type: "session.shutdown", sessionId: sessionManager.sessionId });
-    };
-    const submitPrompt = async (text, mode = "followUp") => {
-        const trimmed = text.trim();
-        if (!trimmed)
-            return;
-        ensureSession();
-        let beforeStartResult;
-        try {
-            beforeStartResult = await hookRunner.emitBeforeAgentStart(trimmed);
-            const hookMsg = beforeStartResult?.message ? createHookMessage(beforeStartResult.message) : null;
-            if (hookMsg?.display) {
-                const uiMsg = {
-                    id: crypto.randomUUID(),
-                    role: "assistant",
-                    content: typeof hookMsg.content === "string"
-                        ? hookMsg.content
-                        : hookMsg.content.map((p) => (p.type === "text" ? p.text : "[image]")).join(""),
-                    timestamp: hookMsg.timestamp,
-                };
-                store.messages.set((prev) => appendWithCap(prev, uiMsg));
-            }
-        }
-        catch (err) {
-            store.messages.set((prev) => appendWithCap(prev, {
-                id: crypto.randomUUID(),
-                role: "assistant",
-                content: `Hook error: ${err instanceof Error ? err.message : String(err)}`,
-                timestamp: Date.now(),
-            }));
+    batch(() => {
+      store.toolBlocks.set([]);
+      store.isResponding.set(true);
+      store.activityState.set("thinking");
+    });
+    try {
+      await Effect.runPromise(runtime.sessionOrchestrator.submitPrompt(trimmed, {
+        mode,
+        beforeStartResult
+      }));
+    } catch (err) {
+      batch(() => {
+        store.messages.set(prev => appendWithCap(prev, {
+          id: crypto.randomUUID(),
+          role: "assistant",
+          content: `Error: ${err instanceof Error ? err.message : String(err)}`
+        }));
+        store.isResponding.set(false);
+        store.activityState.set("idle");
+      });
+    }
+  };
+  const steerHelper = async text => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    if (store.isResponding.value()) {
+      await sessionController.steer(trimmed);
+      return;
+    }
+    await submitPrompt(trimmed, "steer");
+  };
+  const followUpHelper = async text => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    if (store.isResponding.value()) {
+      await sessionController.followUp(trimmed);
+      return;
+    }
+    await submitPrompt(trimmed, "followUp");
+  };
+  const sendUserMessageHelper = async (text, options) => {
+    const mode = options?.deliverAs ?? "followUp";
+    if (mode === "steer") {
+      await steerHelper(text);
+      return;
+    }
+    await followUpHelper(text);
+  };
+  const cmdCtx = {
+    agent,
+    sessionManager,
+    configDir: config.configDir,
+    configPath: config.configPath,
+    cwd: process.cwd(),
+    editor: config.editor,
+    codexTransport,
+    getApiKey,
+    get currentProvider() {
+      return sessionController.currentProvider();
+    },
+    get currentModelId() {
+      return sessionController.currentModelId();
+    },
+    get currentThinking() {
+      return sessionController.currentThinking();
+    },
+    setCurrentProvider: p => sessionController.setCurrentProvider(p),
+    setCurrentModelId: id => sessionController.setCurrentModelId(id),
+    setCurrentThinking: t => sessionController.setCurrentThinking(t),
+    isResponding: store.isResponding.value,
+    setIsResponding: store.isResponding.set,
+    setActivityState: store.activityState.set,
+    setMessages: store.messages.set,
+    setToolBlocks: store.toolBlocks.set,
+    setContextTokens: store.contextTokens.set,
+    setCacheStats: store.cacheStats.set,
+    setDisplayModelId: store.displayModelId.set,
+    setDisplayThinking: store.displayThinking.set,
+    setDisplayContextWindow: store.displayContextWindow.set,
+    setDiffWrapMode: store.diffWrapMode.set,
+    setConcealMarkdown: store.concealMarkdown.set,
+    setTheme: handleThemeChange,
+    openEditor: () => editorOpenRef.current(),
+    onExit: () => exitHandlerRef.current(),
+    hookRunner,
+    submitPrompt: (text, options) => submitPrompt(text, options?.mode ?? "followUp"),
+    steer: text => steerHelper(text),
+    followUp: text => followUpHelper(text),
+    sendUserMessage: (text, options) => sendUserMessageHelper(text, options)
+  };
+  const builtInCommandNames = new Set(slashCommands.map(c => c.name));
+  const enqueueWhileResponding = (text, mode) => {
+    void sendUserMessageHelper(text, {
+      deliverAs: mode
+    }).catch(err => {
+      store.messages.set(prev => appendWithCap(prev, {
+        id: crypto.randomUUID(),
+        role: "assistant",
+        content: `Error: ${err instanceof Error ? err.message : String(err)}`
+      }));
+    });
+  };
+  const handleSubmit = async (text, editorClearFn) => {
+    if (!text.trim()) return;
+    if (text.startsWith("!")) {
+      const shouldInject = text.startsWith("!!");
+      const command = text.slice(shouldInject ? 2 : 1).trim();
+      if (!command) return;
+      editorClearFn?.();
+      ensureSession();
+      const shellMsgId = crypto.randomUUID();
+      const pendingMsg = {
+        id: shellMsgId,
+        role: "shell",
+        command,
+        output: "",
+        exitCode: null,
+        truncated: false,
+        timestamp: Date.now()
+      };
+      store.messages.set(prev => appendWithCap(prev, pendingMsg));
+      const result = await runShellCommand(command, {
+        timeout: 30000
+      });
+      const finalMsg = {
+        id: shellMsgId,
+        role: "shell",
+        command,
+        output: result.output,
+        exitCode: result.exitCode,
+        truncated: result.truncated,
+        tempFilePath: result.tempFilePath,
+        timestamp: Date.now()
+      };
+      store.messages.set(prev => prev.map(m => m.id === shellMsgId ? finalMsg : m));
+      sessionManager.appendMessage({
+        role: "shell",
+        command,
+        output: result.output,
+        exitCode: result.exitCode,
+        truncated: result.truncated,
+        tempFilePath: result.tempFilePath,
+        timestamp: Date.now()
+      });
+      if (shouldInject) {
+        const injectionLines = [`${SHELL_INJECTION_PREFIX}`, `$ ${command}`, result.output];
+        if (result.exitCode !== null && result.exitCode !== 0) injectionLines.push(`[exit ${result.exitCode}]`);
+        if (result.truncated && result.tempFilePath) injectionLines.push(`[truncated, full output: ${result.tempFilePath}]`);
+        const injectedText = injectionLines.filter(line => line.length > 0).join("\n");
+        const injectionMessage = {
+          role: "user",
+          content: [{
+            type: "text",
+            text: injectedText
+          }],
+          timestamp: Date.now()
+        };
+        agent.appendMessage(injectionMessage);
+        sessionManager.appendMessage(injectionMessage);
+      }
+      return;
+    }
+    if (text.startsWith("/")) {
+      const trimmed = text.trim();
+      const handled = await handleSlashInput(trimmed, {
+        commandContext: cmdCtx,
+        customCommands,
+        builtInCommandNames,
+        onExpand: async expanded => handleSubmit(expanded)
+      });
+      if (handled) {
+        // Skip clear if hook populated editor via setEditorText
+        if (!skipNextEditorClearRef.current) {
+          editorClearFn?.();
         }
-        promptQueue.push({ text: trimmed, mode });
-        batch(() => {
-            store.toolBlocks.set([]);
-            store.isResponding.set(true);
-            store.activityState.set("thinking");
+        skipNextEditorClearRef.current = false;
+        return;
+      }
+    }
+    if (store.isResponding.value()) {
+      enqueueWhileResponding(text, "followUp");
+      editorClearFn?.();
+      return;
+    }
+    editorClearFn?.();
+    await submitPrompt(text, "followUp");
+  };
+  // Initialize hook runner with full context
+  const hookUIContext = createHookUIContext({
+    setEditorText: text => {
+      skipNextEditorClearRef.current = true;
+      setEditorTextRef.current(text);
+    },
+    getEditorText: () => getEditorTextRef.current(),
+    showSelect: modals.showSelect,
+    showInput: modals.showInput,
+    showConfirm: modals.showConfirm,
+    showEditor: modals.showEditor,
+    showNotify: (message, type = "info") => showToastRef.current(type, message, type)
+  });
+  const hookSessionContext = {
+    summarize: async () => {
+      // Trigger compaction through the /compact command flow
+      await handleSlashInput("/compact", {
+        commandContext: cmdCtx,
+        customCommands,
+        builtInCommandNames,
+        onExpand: async expanded => handleSubmit(expanded)
+      });
+    },
+    toast: (title, message, variant = "info") => showToastRef.current(title, message, variant),
+    getTokenUsage: () => hookRunner["tokenUsage"],
+    getContextLimit: () => hookRunner["contextLimit"],
+    newSession: async _opts => {
+      // Clear current session and start fresh
+      store.messages.set([]);
+      store.toolBlocks.set([]);
+      store.contextTokens.set(0);
+      agent.reset();
+      void hookRunner.emit({
+        type: "session.clear",
+        sessionId: null
+      });
+      // Start a new session
+      sessionManager.startSession(sessionController.currentProvider(), sessionController.currentModelId(), sessionController.currentThinking());
+      return {
+        cancelled: false,
+        sessionId: sessionManager.sessionId ?? undefined
+      };
+    },
+    getApiKey: async model => getApiKey(model.provider),
+    complete: async (systemPrompt, userText) => {
+      const model = agent.state.model;
+      const apiKey = getApiKey(model.provider);
+      if (!apiKey) {
+        return {
+          text: "",
+          stopReason: "error"
+        };
+      }
+      try {
+        const userMessage = {
+          role: "user",
+          content: [{
+            type: "text",
+            text: userText
+          }],
+          timestamp: Date.now()
+        };
+        const result = await completeSimple(model, {
+          systemPrompt,
+          messages: [userMessage]
+        }, {
+          apiKey
         });
-        try {
-            await Effect.runPromise(runtime.sessionOrchestrator.submitPrompt(trimmed, { mode, beforeStartResult }));
-        }
-        catch (err) {
-            batch(() => {
-                store.messages.set((prev) => appendWithCap(prev, {
-                    id: crypto.randomUUID(),
-                    role: "assistant",
-                    content: `Error: ${err instanceof Error ? err.message : String(err)}`,
-                }));
-                store.isResponding.set(false);
-                store.activityState.set("idle");
-            });
-        }
-    };
-    const steerHelper = async (text) => {
-        const trimmed = text.trim();
-        if (!trimmed)
-            return;
-        if (store.isResponding.value()) {
-            await sessionController.steer(trimmed);
-            return;
-        }
-        await submitPrompt(trimmed, "steer");
-    };
-    const followUpHelper = async (text) => {
-        const trimmed = text.trim();
-        if (!trimmed)
-            return;
-        if (store.isResponding.value()) {
-            await sessionController.followUp(trimmed);
-            return;
-        }
-        await submitPrompt(trimmed, "followUp");
-    };
-    const sendUserMessageHelper = async (text, options) => {
-        const mode = options?.deliverAs ?? "followUp";
-        if (mode === "steer") {
-            await steerHelper(text);
-            return;
-        }
-        await followUpHelper(text);
-    };
-    const cmdCtx = {
-        agent,
-        sessionManager,
-        configDir: config.configDir,
-        configPath: config.configPath,
-        cwd: process.cwd(),
-        editor: config.editor,
-        codexTransport,
-        getApiKey,
-        get currentProvider() {
-            return sessionController.currentProvider();
+        const text = result.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+        // Map stopReason: stop -> end, length -> max_tokens, toolUse -> tool_use
+        const stopMap = {
+          stop: "end",
+          length: "max_tokens",
+          toolUse: "tool_use",
+          error: "error",
+          aborted: "aborted"
+        };
+        return {
+          text,
+          stopReason: stopMap[result.stopReason] ?? "end"
+        };
+      } catch (err) {
+        return {
+          text: err instanceof Error ? err.message : String(err),
+          stopReason: "error"
+        };
+      }
+    }
+  };
+  const sendMessageHandler = (message, triggerTurn) => {
+    const hookMessage = createHookMessage(message);
+    // Add to UI messages if display is true
+    if (hookMessage.display) {
+      const uiMsg = {
+        id: crypto.randomUUID(),
+        role: "assistant",
+        // Render hook messages as assistant for now
+        content: typeof hookMessage.content === "string" ? hookMessage.content : hookMessage.content.map(p => p.type === "text" ? p.text : "[image]").join(""),
+        timestamp: hookMessage.timestamp
+      };
+      store.messages.set(prev => appendWithCap(prev, uiMsg));
+    }
+    // Persist hook message to session
+    sessionManager.appendMessage(hookMessage);
+    // Optionally trigger a new turn
+    if (triggerTurn) {
+      void handleSubmit(typeof hookMessage.content === "string" ? hookMessage.content : "");
+    }
+  };
+  hookRunner.initialize({
+    sendHandler: text => void handleSubmit(text),
+    sendMessageHandler,
+    sendUserMessageHandler: (text, options) => sendUserMessageHelper(text, options),
+    steerHandler: text => steerHelper(text),
+    followUpHandler: text => followUpHelper(text),
+    isIdleHandler: () => !store.isResponding.value(),
+    appendEntryHandler: (customType, data) => sessionManager.appendEntry(customType, data),
+    getSessionId: () => sessionManager.sessionId,
+    getModel: () => agent.state.model,
+    uiContext: hookUIContext,
+    sessionContext: hookSessionContext,
+    hasUI: true
+  });
+  sendRef.current = text => void handleSubmit(text);
+  const handleAbort = () => {
+    if (retryState.abortController) {
+      retryState.abortController.abort();
+      retryState.abortController = null;
+      retryState.attempt = 0;
+      store.retryStatus.set(null);
+    }
+    agent.abort();
+    agent.clearMessageQueue();
+    const restore = promptQueue.drainToScript();
+    Effect.runFork(Effect.catchAll(runtime.sessionOrchestrator.drainToScript, () => Effect.succeed(null)));
+    batch(() => {
+      store.isResponding.set(false);
+      store.activityState.set("idle");
+    });
+    return restore;
+  };
+  const cycleModel = () => {
+    if (cycleModels.length <= 1) return;
+    if (store.isResponding.value()) return;
+    cycleIndex = (cycleIndex + 1) % cycleModels.length;
+    const entry = cycleModels[cycleIndex];
+    sessionController.setCurrentProvider(entry.provider);
+    sessionController.setCurrentModelId(entry.model.id);
+    agent.setModel(entry.model);
+    store.displayModelId.set(entry.model.id);
+    store.displayContextWindow.set(entry.model.contextWindow);
+  };
+  const cycleThinking = () => {
+    const current = sessionController.currentThinking();
+    const next = THINKING_LEVELS[(THINKING_LEVELS.indexOf(current) + 1) % THINKING_LEVELS.length];
+    sessionController.setCurrentThinking(next);
+    agent.setThinkingLevel(next);
+    store.displayThinking.set(next);
+  };
+  const themeMode = detectThemeMode();
+  return _$createComponent(ThemeProvider, {
+    mode: themeMode,
+    get themeName() {
+      return store.theme.value();
+    },
+    onThemeChange: handleThemeChange,
+    get children() {
+      return [_$createComponent(MainView, {
+        validationIssues: validationIssues,
+        get messages() {
+          return store.messages.value();
         },
-        get currentModelId() {
-            return sessionController.currentModelId();
+        get toolBlocks() {
+          return store.toolBlocks.value();
         },
-        get currentThinking() {
-            return sessionController.currentThinking();
+        get isResponding() {
+          return store.isResponding.value();
         },
-        setCurrentProvider: (p) => sessionController.setCurrentProvider(p),
-        setCurrentModelId: (id) => sessionController.setCurrentModelId(id),
-        setCurrentThinking: (t) => sessionController.setCurrentThinking(t),
-        isResponding: store.isResponding.value,
-        setIsResponding: store.isResponding.set,
-        setActivityState: store.activityState.set,
-        setMessages: store.messages.set,
-        setToolBlocks: store.toolBlocks.set,
-        setContextTokens: store.contextTokens.set,
-        setCacheStats: store.cacheStats.set,
-        setDisplayModelId: store.displayModelId.set,
-        setDisplayThinking: store.displayThinking.set,
-        setDisplayContextWindow: store.displayContextWindow.set,
-        setDiffWrapMode: store.diffWrapMode.set,
-        setConcealMarkdown: store.concealMarkdown.set,
-        setTheme: handleThemeChange,
-        openEditor: () => editorOpenRef.current(),
-        onExit: () => exitHandlerRef.current(),
-        hookRunner,
-        submitPrompt: (text, options) => submitPrompt(text, options?.mode ?? "followUp"),
-        steer: (text) => steerHelper(text),
-        followUp: (text) => followUpHelper(text),
-        sendUserMessage: (text, options) => sendUserMessageHelper(text, options),
-    };
-    const builtInCommandNames = new Set(slashCommands.map((c) => c.name));
-    const enqueueWhileResponding = (text, mode) => {
-        void sendUserMessageHelper(text, { deliverAs: mode }).catch((err) => {
-            store.messages.set((prev) => appendWithCap(prev, {
-                id: crypto.randomUUID(),
-                role: "assistant",
-                content: `Error: ${err instanceof Error ? err.message : String(err)}`,
-            }));
-        });
-    };
-    const handleSubmit = async (text, editorClearFn) => {
-        if (!text.trim())
-            return;
-        if (text.startsWith("!")) {
-            const shouldInject = text.startsWith("!!");
-            const command = text.slice(shouldInject ? 2 : 1).trim();
-            if (!command)
-                return;
-            editorClearFn?.();
-            ensureSession();
-            const shellMsgId = crypto.randomUUID();
-            const pendingMsg = {
-                id: shellMsgId,
-                role: "shell",
-                command,
-                output: "",
-                exitCode: null,
-                truncated: false,
-                timestamp: Date.now(),
-            };
-            store.messages.set((prev) => appendWithCap(prev, pendingMsg));
-            const result = await runShellCommand(command, { timeout: 30000 });
-            const finalMsg = {
-                id: shellMsgId,
-                role: "shell",
-                command,
-                output: result.output,
-                exitCode: result.exitCode,
-                truncated: result.truncated,
-                tempFilePath: result.tempFilePath,
-                timestamp: Date.now(),
-            };
-            store.messages.set((prev) => prev.map((m) => (m.id === shellMsgId ? finalMsg : m)));
-            sessionManager.appendMessage({
-                role: "shell",
-                command,
-                output: result.output,
-                exitCode: result.exitCode,
-                truncated: result.truncated,
-                tempFilePath: result.tempFilePath,
-                timestamp: Date.now(),
-            });
-            if (shouldInject) {
-                const injectionLines = [`${SHELL_INJECTION_PREFIX}`, `$ ${command}`, result.output];
-                if (result.exitCode !== null && result.exitCode !== 0)
-                    injectionLines.push(`[exit ${result.exitCode}]`);
-                if (result.truncated && result.tempFilePath)
-                    injectionLines.push(`[truncated, full output: ${result.tempFilePath}]`);
-                const injectedText = injectionLines.filter((line) => line.length > 0).join("\n");
-                const injectionMessage = {
-                    role: "user",
-                    content: [{ type: "text", text: injectedText }],
-                    timestamp: Date.now(),
-                };
-                agent.appendMessage(injectionMessage);
-                sessionManager.appendMessage(injectionMessage);
-            }
-            return;
-        }
-        if (text.startsWith("/")) {
-            const trimmed = text.trim();
-            const handled = await handleSlashInput(trimmed, {
-                commandContext: cmdCtx,
-                customCommands,
-                builtInCommandNames,
-                onExpand: async (expanded) => handleSubmit(expanded),
-            });
-            if (handled) {
-                // Skip clear if hook populated editor via setEditorText
-                if (!skipNextEditorClearRef.current) {
-                    editorClearFn?.();
-                }
-                skipNextEditorClearRef.current = false;
-                return;
-            }
-        }
-        if (store.isResponding.value()) {
-            enqueueWhileResponding(text, "followUp");
-            editorClearFn?.();
-            return;
-        }
-        editorClearFn?.();
-        await submitPrompt(text, "followUp");
-    };
-    // Initialize hook runner with full context
-    const hookUIContext = createHookUIContext({
-        setEditorText: (text) => {
-            skipNextEditorClearRef.current = true;
-            setEditorTextRef.current(text);
+        get activityState() {
+          return store.activityState.value();
         },
-        getEditorText: () => getEditorTextRef.current(),
-        showSelect: modals.showSelect,
-        showInput: modals.showInput,
-        showConfirm: modals.showConfirm,
-        showEditor: modals.showEditor,
-        showNotify: (message, type = "info") => showToastRef.current(type, message, type)
-    });
-    const hookSessionContext = {
-        summarize: async () => {
-            // Trigger compaction through the /compact command flow
-            await handleSlashInput("/compact", {
-                commandContext: cmdCtx,
-                customCommands,
-                builtInCommandNames,
-                onExpand: async (expanded) => handleSubmit(expanded),
-            });
+        get thinkingVisible() {
+          return store.thinkingVisible.value();
         },
-        toast: (title, message, variant = "info") => showToastRef.current(title, message, variant),
-        getTokenUsage: () => hookRunner["tokenUsage"],
-        getContextLimit: () => hookRunner["contextLimit"],
-        newSession: async (_opts) => {
-            // Clear current session and start fresh
-            store.messages.set([]);
-            store.toolBlocks.set([]);
-            store.contextTokens.set(0);
-            agent.reset();
-            void hookRunner.emit({ type: "session.clear", sessionId: null });
-            // Start a new session
-            sessionManager.startSession(sessionController.currentProvider(), sessionController.currentModelId(), sessionController.currentThinking());
-            return { cancelled: false, sessionId: sessionManager.sessionId ?? undefined };
+        get modelId() {
+          return store.displayModelId.value();
         },
-        getApiKey: async (model) => getApiKey(model.provider),
-        complete: async (systemPrompt, userText) => {
-            const model = agent.state.model;
-            const apiKey = getApiKey(model.provider);
-            if (!apiKey) {
-                return { text: "", stopReason: "error" };
-            }
-            try {
-                const userMessage = {
-                    role: "user",
-                    content: [{ type: "text", text: userText }],
-                    timestamp: Date.now(),
-                };
-                const result = await completeSimple(model, { systemPrompt, messages: [userMessage] }, { apiKey });
-                const text = result.content
-                    .filter((c) => c.type === "text")
-                    .map((c) => c.text)
-                    .join("\n");
-                // Map stopReason: stop -> end, length -> max_tokens, toolUse -> tool_use
-                const stopMap = {
-                    stop: "end", length: "max_tokens", toolUse: "tool_use", error: "error", aborted: "aborted"
-                };
-                return { text, stopReason: stopMap[result.stopReason] ?? "end" };
-            }
-            catch (err) {
-                return { text: err instanceof Error ? err.message : String(err), stopReason: "error" };
-            }
+        get thinking() {
+          return store.displayThinking.value();
         },
-    };
-    const sendMessageHandler = (message, triggerTurn) => {
-        const hookMessage = createHookMessage(message);
-        // Add to UI messages if display is true
-        if (hookMessage.display) {
-            const uiMsg = {
-                id: crypto.randomUUID(),
-                role: "assistant", // Render hook messages as assistant for now
-                content: typeof hookMessage.content === "string"
-                    ? hookMessage.content
-                    : hookMessage.content.map(p => p.type === "text" ? p.text : "[image]").join(""),
-                timestamp: hookMessage.timestamp,
-            };
-            store.messages.set((prev) => appendWithCap(prev, uiMsg));
-        }
-        // Persist hook message to session
-        sessionManager.appendMessage(hookMessage);
-        // Optionally trigger a new turn
-        if (triggerTurn) {
-            void handleSubmit(typeof hookMessage.content === "string" ? hookMessage.content : "");
-        }
-    };
-    hookRunner.initialize({
-        sendHandler: (text) => void handleSubmit(text),
-        sendMessageHandler,
-        sendUserMessageHandler: (text, options) => sendUserMessageHelper(text, options),
-        steerHandler: (text) => steerHelper(text),
-        followUpHandler: (text) => followUpHelper(text),
-        isIdleHandler: () => !store.isResponding.value(),
-        appendEntryHandler: (customType, data) => sessionManager.appendEntry(customType, data),
-        getSessionId: () => sessionManager.sessionId,
-        getModel: () => agent.state.model,
-        uiContext: hookUIContext,
-        sessionContext: hookSessionContext,
-        hasUI: true,
-    });
-    sendRef.current = (text) => void handleSubmit(text);
-    const handleAbort = () => {
-        if (retryState.abortController) {
-            retryState.abortController.abort();
-            retryState.abortController = null;
-            retryState.attempt = 0;
-            store.retryStatus.set(null);
+        get provider() {
+          return store.currentProvider.value();
+        },
+        get contextTokens() {
+          return store.contextTokens.value();
+        },
+        get contextWindow() {
+          return store.displayContextWindow.value();
+        },
+        get queueCounts() {
+          return store.queueCounts.value();
+        },
+        get retryStatus() {
+          return store.retryStatus.value();
+        },
+        get turnCount() {
+          return store.turnCount.value();
+        },
+        get lspActive() {
+          return store.lspActive.value();
+        },
+        get diffWrapMode() {
+          return store.diffWrapMode.value();
+        },
+        get concealMarkdown() {
+          return store.concealMarkdown.value();
+        },
+        customCommands: customCommands,
+        onSubmit: handleSubmit,
+        onAbort: handleAbort,
+        onToggleThinking: () => store.thinkingVisible.set(v => !v),
+        onCycleModel: cycleModel,
+        onCycleThinking: cycleThinking,
+        exitHandlerRef: exitHandlerRef,
+        editorOpenRef: editorOpenRef,
+        setEditorTextRef: setEditorTextRef,
+        getEditorTextRef: getEditorTextRef,
+        showToastRef: showToastRef,
+        onBeforeExit: handleBeforeExit,
+        get editor() {
+          return config.editor;
+        },
+        lsp: lsp
+      }), _$createComponent(ModalContainer, {
+        get modalState() {
+          return modals.modalState();
+        },
+        get onClose() {
+          return modals.closeModal;
         }
-        agent.abort();
-        agent.clearMessageQueue();
-        const restore = promptQueue.drainToScript();
-        Effect.runFork(Effect.catchAll(runtime.sessionOrchestrator.drainToScript, () => Effect.succeed(null)));
-        batch(() => {
-            store.isResponding.set(false);
-            store.activityState.set("idle");
-        });
-        return restore;
-    };
-    const cycleModel = () => {
-        if (cycleModels.length <= 1)
-            return;
-        if (store.isResponding.value())
-            return;
-        cycleIndex = (cycleIndex + 1) % cycleModels.length;
-        const entry = cycleModels[cycleIndex];
-        sessionController.setCurrentProvider(entry.provider);
-        sessionController.setCurrentModelId(entry.model.id);
-        agent.setModel(entry.model);
-        store.displayModelId.set(entry.model.id);
-        store.displayContextWindow.set(entry.model.contextWindow);
-    };
-    const cycleThinking = () => {
-        const current = sessionController.currentThinking();
-        const next = THINKING_LEVELS[(THINKING_LEVELS.indexOf(current) + 1) % THINKING_LEVELS.length];
-        sessionController.setCurrentThinking(next);
-        agent.setThinkingLevel(next);
-        store.displayThinking.set(next);
-    };
-    const themeMode = detectThemeMode();
-    return (_jsxs(ThemeProvider, { mode: themeMode, themeName: store.theme.value(), onThemeChange: handleThemeChange, children: [_jsx(MainView, { validationIssues: validationIssues, messages: store.messages.value(), toolBlocks: store.toolBlocks.value(), isResponding: store.isResponding.value(), activityState: store.activityState.value(), thinkingVisible: store.thinkingVisible.value(), modelId: store.displayModelId.value(), thinking: store.displayThinking.value(), provider: store.currentProvider.value(), contextTokens: store.contextTokens.value(), contextWindow: store.displayContextWindow.value(), queueCounts: store.queueCounts.value(), retryStatus: store.retryStatus.value(), turnCount: store.turnCount.value(), lspActive: store.lspActive.value(), diffWrapMode: store.diffWrapMode.value(), concealMarkdown: store.concealMarkdown.value(), customCommands: customCommands, onSubmit: handleSubmit, onAbort: handleAbort, onToggleThinking: () => store.thinkingVisible.set((v) => !v), onCycleModel: cycleModel, onCycleThinking: cycleThinking, exitHandlerRef: exitHandlerRef, editorOpenRef: editorOpenRef, setEditorTextRef: setEditorTextRef, getEditorTextRef: getEditorTextRef, showToastRef: showToastRef, onBeforeExit: handleBeforeExit, editor: config.editor, lsp: lsp }), _jsx(ModalContainer, { modalState: modals.modalState(), onClose: modals.closeModal })] }));
-};
-//# sourceMappingURL=TuiApp.js.map
+      })];
+    }
+  });
+};