@semalt-ai/code 1.8.5 → 1.20.0

package/lib/commands/chat-slash.js

@@ -0,0 +1,415 @@
+'use strict';
+
+// In-chat slash-command handlers, extracted from cmdChat in Task 1.5. Keyed by
+// the canonical registry name (lib/commands/registry.js). Bodies are unchanged
+// except that mutable session fields go through ctx and the session/picker
+// helpers (saveSession, showPendingStep, …) are read from ctx (where cmdChat
+// assigned them). The registry ↔ handler parity check stays in cmdChat.
+
+function createSlashHandlers(ctx) {
+  const {
+    chatHistory, statusBar, inputField, storage, permissionManager,
+    getConfig, setConfig, helpText, readFileContext,
+    refreshInputSearchItems, showPendingStep, activateNavCapture, saveSession,
+    destroy, buildExitArtifacts,
+    dashboardListChats, dashboardListModels, dashboardWhoAmI, dashboardLogout,
+    loginFlow, ensureDefaultModel, resolveTokenLimit,
+    estimateTokens, configShow, isNativeToolsActive, getSystemPrompt,
+    agentExecShell, confirmCatastrophicShell, opts, fs, AUDIT_LOG, dbg,
+    checkpointStore,
+  } = ctx;
+
+  return {
+    exit: async () => {
+      saveSession();
+      destroy(buildExitArtifacts());
+      ctx.resolveExit();
+    },
+
+    '/help': async () => {
+      chatHistory.addMessage({ role: 'system', content: helpText() });
+    },
+
+    '/history': async () => {
+      if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
+      const sessions = storage.list();
+      if (!sessions.length) { chatHistory.addMessage({ role: 'system', content: 'No saved sessions.' }); return; }
+      refreshInputSearchItems();
+      chatHistory.addMessage({ role: 'system', content: '/history' });
+      ctx.pendingAction = { type: 'history', items: sessions, stepIdx: 0 };
+      showPendingStep();
+      statusBar.update('waiting', 'Select session...');
+      activateNavCapture();
+    },
+
+    '/chats': async () => {
+      const config = getConfig();
+      if (!config.auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
+      inputField.setDisabled(true);
+      statusBar.update('thinking', 'Loading chats...');
+      try {
+        const response = await dashboardListChats();
+        const chats = Array.isArray(response && response.chats) ? response.chats : [];
+        if (!chats.length) { chatHistory.addMessage({ role: 'system', content: 'No saved chats found.' }); statusBar.update('idle'); }
+        else {
+          refreshInputSearchItems(chats.map(c => ({ type: 'chat', text: c.title || `chat #${c.id}` })));
+          chatHistory.addMessage({ role: 'system', content: '/chats' });
+          ctx.pendingAction = { type: 'chats', items: chats, stepIdx: 0 };
+          showPendingStep();
+          statusBar.update('waiting', 'Select chat...');
+          activateNavCapture();
+        }
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+        statusBar.update('idle');
+      }
+      inputField.setDisabled(false);
+    },
+
+    '/new': async () => {
+      ctx.messages = [];
+      ctx.currentChatId = null; ctx.savedUpTo = 0;
+      permissionManager.clear();
+      chatHistory.addMessage({ role: 'system', content: '✓ Started new conversation.' });
+    },
+
+    '/login': async () => {
+      inputField.setDisabled(true);
+      statusBar.update('thinking', 'Starting login...');
+      await loginFlow(chatHistory, statusBar);
+      const picked = await ensureDefaultModel();
+      if (picked) {
+        ctx.currentModel = picked.modelId;
+        ctx.resolvedTokenLimit = await resolveTokenLimit(ctx.currentModel);
+        statusBar.setModel(ctx.currentModel);
+        statusBar.setContextLimit(ctx.resolvedTokenLimit);
+        chatHistory.addMessage({ role: 'system', content: `✓ Model → ${picked.name} (${picked.modelId})` });
+      }
+      // Relogin is a principal change: the new token may belong to a different
+      // user, so the surviving currentChatId would otherwise suppress fresh-chat
+      // creation and make saveTurnToDashboard POST to a chat the new user can't
+      // see (404 "Chat not found"). Reset chat context AFTER the new token is
+      // saved (loginFlow) and the model resolved (ensureDefaultModel) so the next
+      // turn's createChatIfNeeded lazily creates a fresh chat under the new token.
+      // Mirror /new's FULL reset (messages + approvals too): retaining the prior
+      // user's messages/approvals across a token change is unsafe. The way back to
+      // an old chat is explicit --resume / /chats.
+      ctx.messages = [];
+      ctx.currentChatId = null; ctx.savedUpTo = 0;
+      permissionManager.clear();
+      statusBar.update('idle');
+      inputField.setDisabled(false);
+    },
+
+    '/whoami': async () => {
+      inputField.setDisabled(true);
+      statusBar.update('thinking', 'Loading...');
+      try {
+        const response = await dashboardWhoAmI();
+        const user = response && response.user ? response.user : null;
+        if (!user) { chatHistory.addMessage({ role: 'system', content: '✗ Unable to load current user.', isError: true }); }
+        else {
+          chatHistory.addMessage({ role: 'system', content: `Current User:\n  ID: ${user.id}\n  Email: ${user.email || '-'}\n  Name: ${user.name || '-'}\n  Provider: ${user.provider || '-'}` });
+        }
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+      }
+      statusBar.update('idle');
+      inputField.setDisabled(false);
+    },
+
+    '/logout': async () => {
+      const config = getConfig();
+      if (!config.auth_token) { chatHistory.addMessage({ role: 'system', content: '✗ Not logged in.' }); return; }
+      inputField.setDisabled(true);
+      statusBar.update('thinking', 'Logging out...');
+      // Defense-in-depth: drop the chat context up front, REGARDLESS of whether
+      // the dashboardLogout HTTP call below succeeds (it early-returns on a
+      // non-401 error), so no later save can target the logged-out user's chat.
+      ctx.currentChatId = null; ctx.savedUpTo = 0;
+      try { await dashboardLogout(); } catch (err) { if (err.statusCode !== 401) { chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true }); statusBar.update('idle'); inputField.setDisabled(false); return; } }
+      setConfig({ ...config, auth_token: '' });
+      chatHistory.addMessage({ role: 'system', content: '✓ Logged out and cleared local CLI token.' });
+      statusBar.update('idle');
+      inputField.setDisabled(false);
+    },
+
+    '/file': async (arg) => {
+      const fp = arg;
+      const fileCtx = readFileContext([fp]);
+      if (fileCtx) {
+        ctx.messages.push({ role: 'user', content: `Here is the file context:\n${fileCtx}` });
+        chatHistory.addMessage({ role: 'system', content: `✓ Loaded: ${fp}` });
+      } else {
+        chatHistory.addMessage({ role: 'system', content: `✗ Could not load: ${fp}`, isError: true });
+      }
+    },
+
+    '/image': async (arg) => {
+      // Multimodal image input (Task 5.4). Stage an image (read through
+      // isPathSafe, size-checked, base64-encoded) for the NEXT user turn, which
+      // attaches and clears it (chat-turn.js). Repeatable to attach several.
+      const fp = (arg || '').trim();
+      if (!fp) { chatHistory.addMessage({ role: 'system', content: '✗ Usage: /image <path>', isError: true }); return; }
+      const { readImage } = require('../images');
+      const { isPathSafe } = require('../tools');
+      try {
+        const img = readImage(fp, { maxBytes: getConfig().image_max_bytes, isPathSafe });
+        ctx.pendingImages = (ctx.pendingImages || []).concat([img]);
+        const kb = Math.max(1, Math.round(img.bytes / 1024));
+        chatHistory.addMessage({ role: 'system', content: `✓ Attached image: ${fp} (${img.media_type}, ${kb} KB). Sent with your next message.` });
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+      }
+    },
+
+    '/models': async () => {
+      if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
+      inputField.setDisabled(true);
+      statusBar.update('thinking', 'Loading models...');
+      try {
+        const response = await dashboardListModels();
+        const models = Array.isArray(response && response.models) ? response.models : [];
+        if (!models.length) { chatHistory.addMessage({ role: 'system', content: '✗ No models available.' }); statusBar.update('idle'); }
+        else {
+          chatHistory.addMessage({ role: 'system', content: '/models' });
+          ctx.pendingAction = { type: 'models', items: models, stepIdx: 0 };
+          showPendingStep();
+          statusBar.update('waiting', 'Select model...');
+          activateNavCapture();
+        }
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ ${err.message}`, isError: true });
+        statusBar.update('idle');
+      }
+      inputField.setDisabled(false);
+    },
+
+    '/model': async (arg) => {
+      if (!getConfig().auth_token) { chatHistory.addMessage({ role: 'system', content: 'Not logged in. Run /login first.' }); return; }
+      if (!arg) {
+        chatHistory.addMessage({ role: 'system', content: `Current model: ${ctx.currentModel}` });
+        return;
+      }
+      ctx.currentModel = arg;
+      ctx.resolvedTokenLimit = await resolveTokenLimit(ctx.currentModel);
+      statusBar.setModel(ctx.currentModel);
+      statusBar.setContextLimit(ctx.resolvedTokenLimit);
+      chatHistory.addMessage({ role: 'system', content: `✓ Model → ${ctx.currentModel}` });
+    },
+
+    '/clear': async () => {
+      ctx.messages = [];
+      ctx.currentChatId = null; ctx.savedUpTo = 0;
+      permissionManager.clear();
+      chatHistory.addMessage({ role: 'system', content: '✓ Conversation and approvals cleared.' });
+    },
+
+    '/compact': async () => {
+      const { selectForCompaction, summarizationRequest, buildCompactedMessages, approxTokens } = require('../compact');
+      const before = approxTokens(ctx.messages, estimateTokens);
+      const sel = selectForCompaction(ctx.messages, { keepRecent: 6 });
+      if (!sel.head.length) {
+        let msg = `Nothing to compact yet — ${ctx.messages.length} messages, ~${before} tokens.`;
+        if (ctx.sessionMetrics) msg += '\n' + ctx.sessionMetrics.summary();
+        chatHistory.addMessage({ role: 'system', content: msg });
+        return;
+      }
+      // PreCompact hook (Task 3.4): fire before summarizing. Best-effort.
+      try {
+        await require('../hooks').createHookRunner({ getConfig })
+          .run('PreCompact', { reason: 'manual', messageCount: ctx.messages.length });
+      } catch { /* hook failures never block compaction */ }
+      inputField.setDisabled(true);
+      statusBar.update('thinking', 'Compacting…');
+      let summary = '';
+      try {
+        summary = await ctx.chatSync(summarizationRequest(sel.head), { model: ctx.currentModel });
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ Compact failed: ${err.message}`, isError: true });
+        statusBar.update('idle'); inputField.setDisabled(false); return;
+      }
+      if (!summary || !summary.trim()) {
+        chatHistory.addMessage({ role: 'system', content: '✗ Compact produced no summary; history unchanged.', isError: true });
+        statusBar.update('idle'); inputField.setDisabled(false); return;
+      }
+      ctx.messages = buildCompactedMessages(sel, summary);
+      const after = approxTokens(ctx.messages, estimateTokens);
+      chatHistory.addMessage({ role: 'system', content: `✓ Compacted ${sel.head.length} older message(s): ~${before} → ~${after} tokens.` });
+      statusBar.update('idle');
+      inputField.setDisabled(false);
+    },
+
+    '/config': async () => {
+      chatHistory.addMessage({ role: 'system', content: configShow(opts.systemPromptFile || null) });
+    },
+
+    '/memory': async () => {
+      const { loadProjectMemory, memoryStatusLines } = require('../memory');
+      const result = loadProjectMemory();
+      chatHistory.addMessage({ role: 'system', content: memoryStatusLines(result).join('\n') });
+    },
+
+    '/skills': async () => {
+      const { loadSkills, skillsStatusLines } = require('../skills');
+      const result = loadSkills();
+      chatHistory.addMessage({ role: 'system', content: skillsStatusLines(result).join('\n') });
+    },
+
+    '/mcp': async () => {
+      const { formatStatus, formatServerList } = require('./mcp');
+      const cfgServers = (getConfig().mcp && getConfig().mcp.servers) || {};
+      const mgr = ctx.mcpManager;
+      const status = mgr ? mgr.status() : [];
+      // Show live connection status when we have it; otherwise list what's
+      // configured (e.g. no servers connected yet).
+      const body = status.length ? formatStatus(status) : formatServerList(cfgServers);
+      chatHistory.addMessage({ role: 'system', content: body });
+    },
+
+    '/doctor': async () => {
+      const { diagnose, formatDoctorReport } = require('../doctor');
+      const ping = async () => {
+        const cfg = getConfig();
+        if (!cfg.auth_token) return null;
+        try { const r = await dashboardWhoAmI(); return !!(r && r.user); } catch { return false; }
+      };
+      const result = await diagnose({ getConfig, pingDashboard: ping });
+      chatHistory.addMessage({ role: 'system', content: formatDoctorReport(result) });
+    },
+
+    '/sandbox': async () => {
+      const { sandboxStatusReport } = require('../sandbox');
+      chatHistory.addMessage({ role: 'system', content: sandboxStatusReport({ getConfig }) });
+    },
+
+    '/plan': async () => {
+      ctx.planMode = !ctx.planMode;
+      if (ctx.planMode) {
+        chatHistory.addMessage({ role: 'system', content: '◷ Plan mode ON — I\'ll investigate with read-only tools and propose a plan. Mutating actions are withheld until you approve. Run /plan again to approve and execute.' });
+      } else {
+        chatHistory.addMessage({ role: 'system', content: '✓ Plan mode OFF — approved. Mutating actions will now execute; tell me to proceed.' });
+      }
+    },
+
+    '/rewind': async (arg) => {
+      const { formatCheckpointList, formatRewindResult, normalizeRewindMode, REWIND_MODES } = require('../checkpoints');
+      if (!checkpointStore) {
+        chatHistory.addMessage({ role: 'system', content: 'Checkpoints are not available in this session.' });
+        return;
+      }
+      const tokens = (arg || '').trim().split(/\s+/).filter(Boolean);
+      const force = tokens.includes('force') || tokens.includes('--force');
+      const modeToken = tokens.find((t) => REWIND_MODES.includes(t.toLowerCase()));
+      const mode = normalizeRewindMode(modeToken);
+      const target = tokens.find((t) => t !== 'force' && t !== '--force' && t !== modeToken);
+      if (!target || target === 'list') {
+        chatHistory.addMessage({ role: 'system', content: formatCheckpointList(checkpointStore.list()) });
+        return;
+      }
+      if (mode === null) {
+        chatHistory.addMessage({ role: 'system', content: `Unknown rewind mode "${modeToken}". Use one of: ${REWIND_MODES.join(', ')}.` });
+        return;
+      }
+      // Pass the live conversation so a conversation/both rewind can truncate it
+      // back to the checkpoint's turn (cutting on a turn boundary, never mid-pair).
+      const res = checkpointStore.rewind(target === 'last' ? 'last' : target, { force, mode, messages: ctx.messages });
+      if (res.conversation && res.conversation.ok) {
+        // Post-rewind policy: DISCARD. The truncated history replaces the active
+        // conversation; the removed tail is dropped (not persisted).
+        ctx.messages = res.conversation.messages;
+        if (typeof ctx.savedUpTo === 'number') ctx.savedUpTo = Math.min(ctx.savedUpTo, ctx.messages.length);
+        saveSession();
+      }
+      chatHistory.addMessage({ role: 'system', content: formatRewindResult(res) });
+    },
+
+    '/prompt': async () => {
+      const nativeTools = isNativeToolsActive(ctx.currentModel);
+      const activePrompt = ctx.resolvedSystemPrompt !== null ? ctx.resolvedSystemPrompt : getSystemPrompt(nativeTools);
+      const src = ctx.resolvedSystemPrompt !== null ? `file: ${opts.systemPromptFile}` : 'built-in';
+      const mode = getConfig().system_prompt_mode || 'system_role';
+      chatHistory.addMessage({
+        role: 'system',
+        content: `System prompt (${src}, mode: ${mode}):\n\n${activePrompt}`,
+      });
+    },
+
+    '/approve': async () => {
+      const enabled = permissionManager.toggleAll();
+      chatHistory.addMessage({ role: 'system', content: `Auto-approve: ${enabled ? 'ON' : 'OFF'}` });
+    },
+
+    '/debug': async (arg) => {
+      const a = arg.toLowerCase();
+      if (a === 'off' || a === 'false' || a === '0') ctx.debugMode = false;
+      else ctx.debugMode = true;
+
+      let tail = '';
+      try {
+        const content = fs.readFileSync(AUDIT_LOG, 'utf8');
+        const lines = content.trim().split('\n').filter((l) => l.trim()).slice(-5);
+        if (lines.length) {
+          const formatted = lines.map((line) => {
+            try {
+              const entry = JSON.parse(line);
+              const mark = entry.approved ? '✓' : '✗';
+              return `  ${mark} ${entry.ts} ${entry.tag} ${entry.input} → ${entry.result}`;
+            } catch {
+              return `  ${line}`;
+            }
+          });
+          tail = '\nLast 5 audit entries:\n' + formatted.join('\n');
+        } else {
+          tail = '\nAudit log is empty.';
+        }
+      } catch {
+        tail = '\nNo audit log found.';
+      }
+
+      const sink = dbg.isFile()
+        ? `file (${dbg.getMode()} mode)`
+        : 'inline chat history';
+      chatHistory.addMessage({
+        role: 'system',
+        content: `Debug output: ${ctx.debugMode ? 'ON' : 'OFF'} → ${sink}${tail}`,
+      });
+    },
+
+    '/shell': async (arg) => {
+      const cmd = arg;
+      inputField.setDisabled(true);
+      statusBar.update('tool', cmd);
+      try {
+        const shellResult = await agentExecShell(cmd, {
+          initiator: 'user',
+          confirm: (label, command) => {
+            chatHistory.addMessage({
+              role: 'system',
+              content: `⚠ Catastrophic command (${label}). Confirm to run:\n${command}`,
+              isError: true,
+            });
+            // _navCapture is checked before _disabled in input-field, so the
+            // picker drives keystrokes even though the field is disabled here.
+            return confirmCatastrophicShell(label, command, {
+              captureNavigation: (h) => { inputField.captureNavigation(h); return () => inputField.releaseNavigation(); },
+            });
+          },
+        });
+        let output = shellResult.stdout || '';
+        if (shellResult.stderr && shellResult.stderr !== 'Permission denied by user') {
+          output += (output ? '\n' : '') + `STDERR: ${shellResult.stderr}`;
+        }
+        const exitSuffix = shellResult.exit_code !== 0 ? `  [exit ${shellResult.exit_code}]` : '';
+        const display = output.trim() ? output.trim() + exitSuffix : `(no output)${exitSuffix}`;
+        chatHistory.addMessage({ role: 'shell', cmd, content: display, ts: new Date() });
+      } catch (err) {
+        chatHistory.addMessage({ role: 'system', content: `✗ Shell error: ${err.message}`, isError: true });
+      }
+      statusBar.update('idle');
+      inputField.setDisabled(false);
+    },
+  };
+}
+
+module.exports = { createSlashHandlers };