@semalt-ai/code 1.8.5 → 1.19.0

package/lib/commands/chat-turn.js

@@ -0,0 +1,446 @@
+'use strict';
+
+// The chat input/turn handler (cmdChat's inputField.onSubmit), extracted in
+// Task 1.5. Handles picker text-fallback navigation, slash-command dispatch, and
+// running a normal message through the agent loop with the full TUI callback
+// wiring. Mutable session fields go through ctx; session/picker/sync helpers and
+// stable collaborators are read from ctx (where cmdChat assigned them). Bodies
+// are unchanged. NOTE: the onToolStart/onToolEnd callbacks take a local `ctx`
+// parameter (the per-tool invocation context) that intentionally shadows the
+// session ctx — those callbacks use only the per-tool fields, never session state.
+
+const { resolveMaxIterations } = require('../config');
+const { createWebActivityTracker } = require('../ui/web-activity');
+
+function createTurnHandler(ctx, slashHandlers) {
+  // The session ctx — the per-tool callbacks below intentionally shadow `ctx`
+  // with the per-invocation context, so capture the session here for the few
+  // session-level reads they need (the live --debug flag).
+  const sessionCtx = ctx;
+  const {
+    inputField, statusBar, chatHistory, getConfig, approxTokens, resolveCommand,
+    runAgentLoop, opts, TAG_REGISTRY, formatToolLine, writerModule,
+    collapseListMsg, handlePendingSelection, showPendingStep, activateNavCapture, finalizeListMsg,
+    createChatIfNeeded, saveTurnToDashboard, saveSession,
+  } = ctx;
+
+  // Running session token totals for the cost indicator (Task 2.6). Each turn's
+  // Metrics is per-turn, so we accumulate here for a session cost in the bar.
+  const sessionUsage = { prompt_tokens: 0, completion_tokens: 0 };
+
+  return async (text) => {
+    // Handle pending selection (text fallback for non-TTY; TTY uses captureNavigation)
+    if (ctx.pendingAction) {
+      inputField.releaseNavigation();
+      const t = text.trim().toLowerCase();
+      const { items, displayItems: di, stepIdx, type } = ctx.pendingAction;
+      const activeItems = di || items;
+      if (t === 's' || t === 'select' || t === 'y' || t === 'yes') {
+        collapseListMsg(type, activeItems[stepIdx]);
+        statusBar.update('idle');
+        await handlePendingSelection(stepIdx);
+        inputField.setDisabled(false);
+        return;
+      } else if (t === 'n' || t === 'next') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: (stepIdx + 1) % items.length };
+        showPendingStep();
+        activateNavCapture();
+        return;
+      } else if (t === 'p' || t === 'prev') {
+        ctx.pendingAction = { ...ctx.pendingAction, stepIdx: (stepIdx - 1 + items.length) % items.length };
+        showPendingStep();
+        activateNavCapture();
+        return;
+      } else if (t === 'c' || t === 'cancel') {
+        finalizeListMsg();
+        chatHistory.addMessage({ role: 'system', content: 'Cancelled.' });
+        ctx.pendingAction = null;
+        statusBar.update('idle');
+        inputField.setDisabled(false);
+        return;
+      } else {
+        // Not a nav key: close nav silently and let the message go to AI
+        finalizeListMsg();
+        ctx.pendingAction = null;
+        statusBar.update('idle');
+        // fall through to AI processing below
+      }
+    }
+
+    // Slash-command dispatch via the registry (replaces the former if-chain).
+    // resolveCommand maps the raw text to a canonical command + its argument;
+    // null means "not a command" → fall through to the agent below.
+    const resolved = resolveCommand(text);
+    if (resolved) {
+      if (resolved.spec && resolved.spec.custom) {
+        // Custom (Markdown) command: render its template and let it fall through
+        // to the agent path below as the user prompt. It is submitted as text,
+        // never executed as code.
+        const { renderTemplate } = require('./custom');
+        text = renderTemplate(resolved.spec.template, resolved.arg);
+        if (!text.trim()) {
+          chatHistory.addMessage({ role: 'system', content: `✗ Custom command ${resolved.name} produced an empty prompt.`, isError: true });
+          return;
+        }
+      } else if (resolved.spec && resolved.spec.skill) {
+        // Skill invocation (Task 3.5): the system prompt carried only the skill's
+        // metadata. Loading the body HERE — on invocation — is the progressive
+        // disclosure: the instructions enter context only now. The body is read
+        // from SKILL.md, rendered (so $ARGUMENTS/$1 work if the author used them),
+        // and submitted to the agent as a user prompt, never executed as code.
+        const { loadSkillBody } = require('../skills');
+        const { renderTemplate } = require('./custom');
+        let body;
+        try { body = loadSkillBody(resolved.spec); } catch { body = ''; }
+        if (!body || !body.trim()) {
+          chatHistory.addMessage({ role: 'system', content: `✗ Skill ${resolved.name} has no loadable body.`, isError: true });
+          return;
+        }
+        const rendered = renderTemplate(body, resolved.arg);
+        // Skills may carry assets/scripts alongside SKILL.md — tell the agent where.
+        text = rendered + (resolved.spec.dir ? `\n\n(Skill assets directory: ${resolved.spec.dir})` : '');
+      } else {
+        await slashHandlers[resolved.name](resolved.arg, text);
+        return;
+      }
+    }
+
+
+    // Block unauthenticated users from running the agent
+    if (!getConfig().auth_token) {
+      chatHistory.addMessage({ role: 'system', content: '✗ Not logged in. Run /login first.', isError: true });
+      return;
+    }
+
+    // Normal message → run agent
+    inputField.setDisabled(true);
+    chatHistory.addMessage({ role: 'user', content: text });
+    statusBar.update('thinking', 'Thinking...');
+    // Bump the context-size indicator with this user message's approximate
+    // token count. It'll be overwritten with the exact prompt_tokens from
+    // the API response when the first turn completes — this just keeps the
+    // indicator reactive in the gap before that.
+    statusBar.addPendingTokens(approxTokens(text));
+    await createChatIfNeeded(text);
+    // Multimodal image input (Task 5.4): consume any images staged by /image and
+    // attach them to this user turn, then clear the staging buffer.
+    const stagedImages = (ctx.pendingImages && ctx.pendingImages.length) ? ctx.pendingImages : null;
+    ctx.pendingImages = [];
+    const userMessage = { role: 'user', content: text };
+    if (stagedImages) userMessage.images = stagedImages;
+    ctx.messages.push(userMessage);
+
+    // Per-turn state: buffer tokens until we know if the model is in an implicit
+    // think block (Qwen3-style: plain text followed by </think>, no opening tag).
+    let implicitThinkPhase = !opts.showThink;
+    let implicitThinkBuffer = '';
+
+    // Web-activity collapse (Task W.3): in the default (non-debug) view, a run of
+    // consecutive web ops (web_search → http_get) renders as ONE process-summary
+    // line instead of a per-op line each. Fresh per turn. In --debug the tracker
+    // is bypassed and web ops render the normal per-op way (full detail).
+    const webTracker = createWebActivityTracker({ writerModule });
+
+    const callbacks = {
+      onThinking: () => statusBar.update('thinking', 'Thinking...'),
+      onRequestSent: () => {
+        statusBar.update('thinking', 'Thinking...');
+        // Reset think-phase detection for each new agent iteration.
+        implicitThinkPhase = !opts.showThink;
+        implicitThinkBuffer = '';
+      },
+      onStreamStart: () => {
+        // If showThink is on, switch to streaming immediately.
+        // Otherwise keep "Thinking…" until </think> is resolved.
+        if (opts.showThink) statusBar.update('streaming', 'Streaming response');
+      },
+      onTagOpen: (tag, attrs) => {
+        const entry = TAG_REGISTRY[tag];
+        if (entry?.type === 'tool') {
+          const actionLabel = entry.label || tag;
+          const detail = attrs.path || attrs.url || attrs.key || attrs.src || '';
+          const isDownload = tag === 'download' || tag === 'http_get';
+          const barState = isDownload ? 'waiting_download' : 'tool';
+          const label = isDownload
+            ? `Waiting for download${detail ? ': ' + detail : ''}`
+            : `${actionLabel}${detail ? ': ' + detail : ''}`;
+          statusBar.update(barState, label);
+          if (!opts.showThink) chatHistory.clearStreamingContent();
+        }
+        if (entry?.display === 'think_bubble') {
+          statusBar.update('thinking', 'Reasoning...');
+        }
+      },
+      onThinkEnd: (content) => {
+        chatHistory.addMessage({ role: 'think', content });
+        statusBar.update('streaming', 'Streaming response');
+      },
+      onPermissionAsk: (tag, input) => {
+        // Status-bar update fires while the permission picker is open so
+        // the user can see what's pending in the side label, not just
+        // inside the modal. Mirrors the labels onToolStart uses post-grant
+        // — the next streaming/idle state will overwrite this when the
+        // picker closes (whether granted or denied).
+        const actionLabel = TAG_REGISTRY[tag]?.label || tag;
+        const short = input && input.length > 40 ? input.slice(0, 40) + '…' : (input || '');
+        const isDownload = tag === 'download' || tag === 'http_get';
+        if (isDownload) {
+          statusBar.update('waiting_download', `Waiting for download: ${short}`);
+        } else {
+          statusBar.update('tool', `${actionLabel}: ${short}`);
+        }
+      },
+      onToolStart: (tag, input, ctx) => {
+        const actionLabel = TAG_REGISTRY[tag]?.label || tag;
+        const short = input && input.length > 40 ? input.slice(0, 40) + '…' : (input || '');
+        const isDownload = tag === 'download' || tag === 'http_get';
+        if (isDownload) {
+          statusBar.update('waiting_download', `Waiting for download: ${short}`);
+        } else {
+          statusBar.update('tool', `${actionLabel}: ${short}`);
+        }
+        // Web-activity collapse (Task W.3): in the default view, fold this web op
+        // into the running process-summary line instead of its own activity row.
+        // --debug keeps the per-op line (fall through to the normal path below).
+        if (!sessionCtx.debugMode && webTracker.isWeb(tag)) {
+          webTracker.start(tag, input);
+          return;
+        }
+        // A non-web tool (or debug mode) closes any open web group first, so its
+        // committed summary lands ABOVE this tool's line in scrollback.
+        if (webTracker.isOpen()) webTracker.flush();
+        // Register the invocation with the writer's activity region.
+        // The render function is re-invoked by the writer on every
+        // redraw so the pending line's elapsed time stays current with
+        // the ticker cadence without an explicit refresh timer.
+        //
+        // ask_user is the only currently-blocking tool — it pauses the
+        // agent until the user responds via the modal. A ticking
+        // elapsed-time meter on a paused tool is misleading ("13s"
+        // suggests work is happening), and the per-tick redraw
+        // interacts badly with the open modal (see TECHNICAL_DEBT.md).
+        // Render once with no duration meta and freeze. Replace this
+        // name check with a category flag (e.g. blocking: true on the
+        // tool spec) if more blocking tools appear.
+        if (ctx && ctx.id) {
+          if (tag === 'ask_user') {
+            const staticLine = formatToolLine({
+              status: 'pending',
+              tag,
+              arg: input,
+              attrs: ctx.attrs,
+              noDuration: true,
+            });
+            writerModule.startActivity(ctx.id, () => staticLine);
+          } else {
+            writerModule.startActivity(ctx.id, (elapsedMs) => formatToolLine({
+              status: 'pending',
+              tag,
+              arg: input,
+              attrs: ctx.attrs,
+              durationMs: elapsedMs,
+            }));
+          }
+        }
+      },
+      onToolEnd: (tag, result, durationMs, ctx) => {
+        const hasError = !!(ctx && ctx.error);
+        // Web-activity collapse (Task W.3): record this web op into the running
+        // summary instead of committing a per-op line. The summary reflects the
+        // failure (a 403/406 or timeout shows as "blocked"); the detailed error
+        // body stays hidden in the collapsed view (visible under --debug).
+        if (!sessionCtx.debugMode && webTracker.isWeb(tag)) {
+          webTracker.end(tag, result, durationMs, ctx);
+          if (hasError) statusBar.update('streaming', 'Streaming response');
+          return;
+        }
+        const isBlocking = tag === 'ask_user';
+        const finalLine = formatToolLine({
+          status: hasError ? 'failure' : 'success',
+          tag,
+          arg: ctx && ctx.attrs ? (ctx.attrs.command || ctx.attrs.path || ctx.attrs.url || ctx.attrs.src || ctx.attrs.key || ctx.attrs.name || ctx.attrs.pattern) : '',
+          attrs: ctx ? ctx.attrs : null,
+          durationMs,
+          meta: ctx ? ctx.meta : null,
+          error: ctx ? ctx.error : null,
+          noDuration: isBlocking,
+        });
+        if (ctx && ctx.id) {
+          writerModule.endActivity(ctx.id, finalLine);
+        } else {
+          // No invocation id means the agent-loop wasn't upgraded to pass
+          // structured context (shouldn't happen in practice). Fall back
+          // to a direct scrollback line so the tool still leaves a trace.
+          writerModule.scrollback(finalLine);
+        }
+        if (hasError) {
+          // Preserve the expandable error body as a follow-up tool
+          // bubble. Empty content suppresses its header so the scrollback
+          // line above (written by endActivity) isn't duplicated.
+          const body = typeof result === 'string' && result.trim() ? result : null;
+          if (body) {
+            chatHistory.addMessage({ role: 'tool', tag, content: '', output: body, isError: true });
+          }
+          statusBar.update('streaming', 'Streaming response');
+        }
+      },
+      onToken: (token) => {
+        if (!opts.showThink && implicitThinkPhase) {
+          // Check if this token is the closing think tag (Qwen3-style implicit think).
+          if (/^<\/(think|reasoning|reflection)>$/i.test(token.trim())) {
+            // Thinking phase is over — discard buffered reasoning, start streaming.
+            implicitThinkPhase = false;
+            implicitThinkBuffer = '';
+            statusBar.update('streaming', 'Streaming response');
+            return;
+          }
+          // Buffer the token; keep the thinking animation visible.
+          implicitThinkBuffer += token;
+          return;
+        }
+        chatHistory.streamToken(token);
+        statusBar.onToken();
+      },
+      onAssistantMessage: (cleanContent) => {
+        // If </think> was never seen, the model had no implicit think block —
+        // flush whatever was buffered as normal streaming content.
+        if (implicitThinkPhase && implicitThinkBuffer) {
+          implicitThinkPhase = false;
+          implicitThinkBuffer = '';
+        }
+        // Web-activity ordering (W.3 regression fix): commit any still-open web
+        // group BEFORE the answer is finalized, so the collapsed "✓ web · …"
+        // summary lands ABOVE the answer in scrollback (pre-W.3 ordering).
+        //
+        // Guard on non-empty content: that is exactly the "terminal response"
+        // signal. Intermediate web-tool iterations pass cleanContent === ''
+        // (suppressed because they carried tool calls — agent.js), so they do
+        // NOT flush — the group stays open and the multi-step search→fetch
+        // activity stays collapsed into a single line (the W.3 guarantee).
+        // The final-answer iteration passes non-empty content → flush once.
+        // Empty/interrupted turns (no non-empty message ever arrives) fall back
+        // to the turn-end `finally` flush, which is now the safety net.
+        if (cleanContent && cleanContent.trim() && webTracker.isOpen()) {
+          webTracker.flush();
+        }
+        chatHistory.finalizeLastMessage(cleanContent);
+      },
+      onMetricsUpdate: (data) => statusBar.updateMetrics(data),
+      onRetry: (attempt, max) => {
+        statusBar.update('thinking', `Retrying (${attempt}/${max})...`);
+      },
+      onDebug: (block) => {
+        // Render in-history as a tool-style bubble so ctrl+O expand works and
+        // the RAW RESPONSE text survives TUI redraws (stderr would be clobbered).
+        chatHistory.addMessage({ role: 'tool', tag: 'debug', content: 'DEBUG', output: block });
+      },
+      onError: (err) => {
+        if (err && err.isWarning) {
+          chatHistory.addMessage({ role: 'system', content: err.message || String(err) });
+        } else {
+          const msg = (err && err.message) || String(err);
+          statusBar.update('error', msg);
+          chatHistory.addMessage({ role: 'system', content: `✗ ${msg}`, isError: true });
+        }
+      },
+      onPlanWithhold: (tag, arg) => {
+        chatHistory.addMessage({ role: 'system', content: `⏸ Planned (withheld): ${tag}${arg ? ' ' + arg : ''}` });
+      },
+    };
+
+    let _agentAborted = false;
+    const _onAbort = () => {
+      if (!_agentAborted) {
+        _agentAborted = true;
+        chatHistory.addMessage({ role: 'system', content: '⏹ Interrupted.' });
+      }
+    };
+    inputField.on('abort', _onAbort);
+
+    // Refresh in case a prior turn's 400 overflow persisted a learned
+    // context_length to config after this chat started.
+    if (ctx.resolvedTokenLimit == null) {
+      const cfg = getConfig();
+      if (Number.isInteger(cfg.context_length) && cfg.context_length > 0) {
+        ctx.resolvedTokenLimit = cfg.context_length;
+      }
+    }
+
+    // Auto-compaction near the context limit (Task 2.7): summarize older turns
+    // before the request so they survive as a summary rather than being dropped
+    // by api.js trimToTokenBudget. Best-effort; never blocks the turn.
+    try {
+      const { shouldAutoCompact, selectForCompaction, summarizationRequest, buildCompactedMessages, approxTokens: approxTok } = require('../compact');
+      const lim = ctx.resolvedTokenLimit;
+      const used = approxTok(ctx.messages, approxTokens);
+      if (shouldAutoCompact(used, lim, ctx.messages.length)) {
+        const sel = selectForCompaction(ctx.messages, { keepRecent: 6 });
+        if (sel.head.length) {
+          // PreCompact hook (Task 3.4): fire before summarizing. Best-effort.
+          try {
+            await require('../hooks').createHookRunner({ getConfig })
+              .run('PreCompact', { reason: 'auto', messageCount: ctx.messages.length });
+          } catch { /* hook failures never block compaction */ }
+          const summary = await ctx.chatSync(summarizationRequest(sel.head), { model: ctx.currentModel });
+          if (summary && summary.trim()) {
+            ctx.messages = buildCompactedMessages(sel, summary);
+            const after = approxTok(ctx.messages, approxTokens);
+            chatHistory.addMessage({ role: 'system', content: `✓ Auto-compacted near context limit: ~${used} → ~${after} tokens.` });
+          }
+        }
+      }
+    } catch { /* auto-compaction is best-effort */ }
+
+    try {
+      const agentResult = await runAgentLoop(ctx.messages, ctx.currentModel, resolveMaxIterations(getConfig().max_iterations), ctx.resolvedTokenLimit, {
+        showThink: opts.showThink || false,
+        debug: ctx.debugMode,
+        callbacks,
+        systemPrompt: ctx.resolvedSystemPrompt,
+        systemPromptMode: getConfig().system_prompt_mode || 'system_role',
+        getAbortFlag: () => _agentAborted,
+        getPlanMode: () => ctx.planMode,
+        noVerify: !!opts.noVerify,
+      });
+      ctx.messages = agentResult.messages;
+      ctx.sessionMetrics = agentResult.metrics;
+
+      // Cost indicator (Task 2.6): accumulate this turn's usage and render the
+      // session cost. Unknown model price → "unknown", never a fake $0.
+      try {
+        const cfg = getConfig();
+        if (cfg.show_cost && agentResult.metrics && Array.isArray(agentResult.metrics.turns)) {
+          for (const t of agentResult.metrics.turns) {
+            sessionUsage.prompt_tokens += t.promptTokens || 0;
+            sessionUsage.completion_tokens += t.completionTokens || 0;
+          }
+          const { priceForModel, computeCost, formatCost } = require('../pricing');
+          const cost = computeCost(sessionUsage, priceForModel(ctx.currentModel, cfg.pricing));
+          if (typeof statusBar.setCost === 'function') statusBar.setCost(formatCost(cost));
+        }
+      } catch { /* cost display is best-effort */ }
+
+      if (ctx.planMode && agentResult.withheldActions && agentResult.withheldActions.length) {
+        chatHistory.addMessage({
+          role: 'system',
+          content: `Plan ready — ${agentResult.withheldActions.length} action(s) withheld. Run /plan to approve and execute, or /clear to discard.`,
+        });
+      }
+    } catch (err) {
+      statusBar.update('error', err.message || 'Agent error');
+      chatHistory.addMessage({ role: 'system', content: err.message || 'Agent error', isError: true });
+    } finally {
+      // Commit any still-open web-activity summary (the turn may have ended right
+      // after a web op, or been interrupted mid-group) before the turn unwinds.
+      try { webTracker.flush(); } catch { /* never block turn teardown */ }
+      inputField.removeListener('abort', _onAbort);
+    }
+
+    statusBar.update('idle');
+    inputField.setDisabled(false);
+    await saveTurnToDashboard();
+    saveSession();
+  };
+}
+
+module.exports = { createTurnHandler };