apex-dev 3.0.2 → 3.1.0

package/src/agent.js

@@ -1,504 +0,0 @@
-'use strict';
-
-const {
-  NVIDIA_MODEL,
-  MAX_TOOL_ITERATIONS,
-  nvidiaClient,
-  session,
-  sleep,
-  getMode,
-} = require('./config');
-const { buildSystemPrompt } = require('./prompt');
-const { toolDefs } = require('./tools');
-const { executeTool } = require('./toolExecutors');
-const { toolDetailStr } = require('./utils');
-const store = require('./store');
-const {
-  parseThinkBlocks,
-  findThinkClose,
-  stripStrayCloseTag,
-  splitAtPartialTag,
-} = require('./thinking');
-
-// ===== State =====
-let isProcessing = false;
-
-function getIsProcessing() { return isProcessing; }
-
-// ===== Exploration Detection =====
-const EXPLORATION_KEYWORDS = [
-  'explore', 'find files', 'where is', 'search for', 'locate',
-  'what files', 'which files', 'show me all', 'list all',
-  'find code', 'search code', 'find function', 'find class',
-  'find module', 'find component', 'find endpoint', 'find route',
-  'find api', 'find service', 'find model', 'find controller',
-  'where can i find', 'how do i find', 'look for',
-  'codebase structure', 'project structure', 'directory structure'
-];
-
-function isExplorationTask(text) {
-  const lower = text.toLowerCase();
-  return EXPLORATION_KEYWORDS.some(keyword => lower.includes(keyword));
-}
-
-// ===== Complexity Detection (for MAX mode auto-thinker) =====
-const COMPLEX_TASK_KEYWORDS = [
-  'refactor', 'redesign', 'architect', 'migrate', 'overhaul',
-  'implement', 'build', 'create a system', 'design pattern',
-  'add feature', 'new feature', 'integrate', 'convert',
-  'multiple files', 'across files', 'full stack',
-  'database schema', 'api endpoint', 'authentication',
-  'complex', 'tricky', 'challenging', 'difficult',
-];
-
-function isComplexTask(text) {
-  const lower = text.toLowerCase();
-  const wordCount = text.split(/\s+/).length;
-  const keywordMatch = COMPLEX_TASK_KEYWORDS.some(kw => lower.includes(kw));
-  return keywordMatch || wordCount > 40;
-}
-
-// ===== AI Conversation — Agentic Loop =====
-async function handleUserInput(userInput) {
-  isProcessing = true;
-  store.setState({ isProcessing: true });
-  session.turnCount++;
-
-  store.addMessage({ role: 'user', content: userInput });
-  session.conversationHistory.push({ role: 'user', content: userInput });
-
-  // Auto-delegate to FilePickerMax for exploration tasks
-  if (isExplorationTask(userInput)) {
-    const exploreId = store.addMessage({ role: 'system', content: 'Exploring codebase...', label: '🔍 Exploring' });
-    try {
-      const pickerResult = await executeTool('FilePickerMax', { prompt: userInput }, (partial) => {
-        store.updateMessage(exploreId, { content: partial, label: '🔍 Exploring' });
-      });
-      store.updateMessage(exploreId, { content: pickerResult, label: '🔍 Codebase Exploration Results' });
-      session.conversationHistory.push({
-        role: 'assistant',
-        content: `I've explored the codebase and found the following relevant files:\n\n${pickerResult}`,
-      });
-    } catch (err) {
-      store.updateMessage(exploreId, { content: `Exploration failed: ${err.message}` });
-    }
-  }
-
-  // MAX mode: Auto-think before complex tasks
-  const mode = getMode();
-  if (mode === 'max' && isComplexTask(userInput)) {
-    const thinkId = store.addMessage({ role: 'system', content: 'Deep thinking...', label: '🧠 Thinker' });
-    try {
-      const thinkerResult = await executeTool('Thinker', { prompt: userInput }, (partial) => {
-        store.updateMessage(thinkId, { content: partial, label: '🧠 Thinker' });
-      });
-      store.updateMessage(thinkId, { content: thinkerResult, label: '🧠 Thinker' });
-      session.conversationHistory.push({
-        role: 'assistant',
-        content: `[Thinker analysis]\n${thinkerResult}`,
-      });
-    } catch (err) {
-      store.updateMessage(thinkId, { content: `Thinker failed: ${err.message}` });
-    }
-  }
-
-  // MAX mode: Auto-prune context when history is long
-  if (mode === 'max' && session.conversationHistory.length > 20) {
-    try {
-      await executeTool('ContextPruner', {}, null);
-    } catch { /* ignore pruning failures */ }
-  }
-
-  const startTime = Date.now();
-  let turnTokens = 0;
-  let turnToolCalls = 0;
-
-  try {
-    // Add assistant header message
-    store.addMessage({ role: 'divider' });
-
-    const systemPrompt = buildSystemPrompt();
-    let messages = [
-      { role: 'system', content: systemPrompt },
-      ...session.conversationHistory,
-    ];
-
-    let iterations = 0;
-
-    while (iterations < MAX_TOOL_ITERATIONS) {
-      iterations++;
-
-      let stream;
-      const maxRetries = 3;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-          stream = await nvidiaClient.chat.completions.create({
-            model: NVIDIA_MODEL,
-            messages: messages.map(m => {
-              const clean = { role: m.role, content: m.content };
-              if (m.tool_calls) clean.tool_calls = m.tool_calls.map(tc => ({
-                id: tc.id, type: 'function',
-                function: { name: tc.function.name, arguments: tc.function.arguments },
-              }));
-              if (m.tool_call_id) clean.tool_call_id = m.tool_call_id;
-              if (m.role === 'assistant' && !m.content) clean.content = null;
-              return clean;
-            }),
-            max_tokens: 4096,
-            temperature: 0.6,
-            top_p: 0.95,
-            tools: toolDefs,
-            tool_choice: 'auto',
-            stream: true,
-          });
-          break;
-        } catch (apiErr) {
-          if (attempt < maxRetries && apiErr.status >= 400 && apiErr.status < 500) {
-            await sleep(1000 * Math.pow(2, attempt));
-            continue;
-          }
-          throw apiErr;
-        }
-      }
-
-      // Accumulate streamed response
-      let fullContent = '';
-      const toolCallDeltas = {};
-      const toolCallMsgIds = {};
-      const seenToolCalls = new Set();
-      let finishReason = null;
-      let streamUsage = null;
-      let reasoningText = '';
-
-      // Display state
-      let displayState = 'buffering';
-      let contentAccum = '';
-      let thinkAccum = '';
-      let displayContent = '';
-      let thinkContent = '';
-      let lastFlushTime = Date.now();
-
-      for await (const chunk of stream) {
-        if (chunk.usage) streamUsage = chunk.usage;
-
-        const delta = chunk.choices?.[0]?.delta;
-        if (!delta) {
-          if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
-          continue;
-        }
-        if (chunk.choices[0].finish_reason) finishReason = chunk.choices[0].finish_reason;
-
-        // Tool call deltas
-        if (delta.tool_calls) {
-          for (const tc of delta.tool_calls) {
-            const idx = tc.index;
-            if (!toolCallDeltas[idx]) {
-              toolCallDeltas[idx] = { id: tc.id || '', name: tc.function?.name || '', arguments: '' };
-            }
-            if (tc.id) toolCallDeltas[idx].id = tc.id;
-            if (tc.function?.name) {
-              toolCallDeltas[idx].name = tc.function.name;
-              if (!seenToolCalls.has(idx)) {
-                seenToolCalls.add(idx);
-                toolCallMsgIds[idx] = store.addMessage({
-                  role: 'tool',
-                  name: tc.function.name,
-                  detail: '...',
-                  status: 'pending',
-                });
-              }
-            }
-            if (tc.function?.arguments) {
-              toolCallDeltas[idx].arguments += tc.function.arguments;
-            }
-          }
-        }
-
-        if (delta.reasoning_content) {
-          reasoningText += delta.reasoning_content;
-          store.updateStreaming(displayContent, reasoningText);
-        }
-
-        // Handle content tokens
-        if (delta.content) {
-          fullContent += delta.content;
-          const hasTool = Object.keys(toolCallDeltas).length > 0;
-
-          if (displayState === 'streaming') {
-            contentAccum += delta.content;
-            contentAccum = stripStrayCloseTag(contentAccum);
-            const openIdx = contentAccum.indexOf('<think>');
-            if (openIdx !== -1) {
-              if (openIdx > 0) displayContent += contentAccum.slice(0, openIdx);
-              thinkAccum = contentAccum.slice(openIdx + 7);
-              contentAccum = '';
-              displayState = 'thinking';
-              const closeMatch = findThinkClose(thinkAccum);
-              if (closeMatch) {
-                const thought = thinkAccum.slice(0, closeMatch.pos).trim();
-                const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
-                thinkAccum = '';
-                if (thought) store.addMessage({ role: 'thinking', content: thought });
-                displayState = 'streaming';
-                contentAccum = after;
-                if (!hasTool && after) displayContent += after;
-                contentAccum = '';
-                thinkContent = '';
-              } else {
-                thinkContent = thinkAccum;
-              }
-            } else {
-              const { safe, pending } = splitAtPartialTag(contentAccum);
-              contentAccum = pending;
-              if (!hasTool && safe) displayContent += safe;
-            }
-            store.updateStreaming(displayContent, thinkContent || reasoningText);
-
-          } else if (displayState === 'thinking') {
-            thinkAccum += delta.content;
-            const closeMatch = findThinkClose(thinkAccum);
-            if (closeMatch) {
-              const thought = thinkAccum.slice(0, closeMatch.pos).trim();
-              const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
-              thinkAccum = '';
-              if (thought) store.addMessage({ role: 'thinking', content: thought });
-              displayState = 'streaming';
-              contentAccum = after;
-              if (!hasTool && after) displayContent += after;
-              contentAccum = '';
-              thinkContent = '';
-              store.updateStreaming(displayContent, reasoningText);
-            } else {
-              thinkContent = thinkAccum;
-              store.updateStreaming(displayContent, thinkContent || reasoningText);
-            }
-
-          } else {
-            // buffering
-            contentAccum += delta.content;
-            contentAccum = stripStrayCloseTag(contentAccum);
-            const openIdx = contentAccum.indexOf('<think>');
-            if (openIdx !== -1) {
-              const before = contentAccum.slice(0, openIdx);
-              thinkAccum = contentAccum.slice(openIdx + 7);
-              contentAccum = '';
-              if (!hasTool && before.trim()) displayContent += before;
-              displayState = 'thinking';
-              const closeMatch = findThinkClose(thinkAccum);
-              if (closeMatch) {
-                const thought = thinkAccum.slice(0, closeMatch.pos).trim();
-                const after = thinkAccum.slice(closeMatch.pos + closeMatch.len);
-                thinkAccum = '';
-                if (thought) store.addMessage({ role: 'thinking', content: thought });
-                displayState = 'streaming';
-                contentAccum = after;
-                if (!hasTool && after) displayContent += after;
-                contentAccum = '';
-                thinkContent = '';
-              } else {
-                thinkContent = thinkAccum;
-              }
-              store.updateStreaming(displayContent, thinkContent || reasoningText);
-            } else {
-              const { safe, pending } = splitAtPartialTag(contentAccum);
-              if (safe.length > 0) {
-                displayState = 'streaming';
-                if (!hasTool) displayContent += safe;
-                contentAccum = pending;
-                store.updateStreaming(displayContent, reasoningText);
-              }
-            }
-          }
-        }
-
-        // Yield to the event loop periodically so the terminal renderer can paint
-        const now = Date.now();
-        if (now - lastFlushTime > 16) {
-          lastFlushTime = now;
-          await new Promise(r => setTimeout(r, 1));
-        }
-      }
-
-      // Stream ended — flush remaining buffers
-      if (displayState === 'thinking') {
-        const thought = (thinkAccum + contentAccum).trim();
-        if (thought) store.addMessage({ role: 'thinking', content: thought });
-        thinkAccum = '';
-        contentAccum = '';
-      } else if (displayState === 'buffering') {
-        const hasTool = Object.keys(toolCallDeltas).length > 0;
-        if (!hasTool && contentAccum.trim()) displayContent += contentAccum;
-        contentAccum = '';
-      } else if (contentAccum) {
-        const hasTool = Object.keys(toolCallDeltas).length > 0;
-        if (!hasTool) displayContent += contentAccum;
-        contentAccum = '';
-      }
-
-      // Show reasoning from reasoning_content field
-      if (reasoningText.trim()) {
-        store.addMessage({ role: 'thinking', content: reasoningText.trim() });
-      }
-
-      const { content: parsedContent } = parseThinkBlocks(fullContent);
-      turnTokens += streamUsage?.total_tokens || 0;
-
-      // Reconstruct tool calls
-      const sortedIndices = Object.keys(toolCallDeltas).sort((a, b) => a - b);
-      const toolCalls = sortedIndices.map(idx => ({
-        id: toolCallDeltas[idx].id,
-        type: 'function',
-        function: { name: toolCallDeltas[idx].name, arguments: toolCallDeltas[idx].arguments },
-      }));
-
-      const msg = {
-        role: 'assistant',
-        content: fullContent || null,
-        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
-      };
-
-      // If the model wants to call tools
-      if (toolCalls.length > 0) {
-        store.clearStreaming();
-        messages.push(msg);
-
-        // Show intermediate text if any
-        if (displayContent.trim()) {
-          store.addMessage({ role: 'assistant', content: displayContent.trim() });
-        }
-
-        // Update tool messages with full args and execute
-        sortedIndices.forEach((idx, i) => {
-          const tc = toolCalls[i];
-          let toolArgs;
-          try { toolArgs = JSON.parse(tc.function.arguments); } catch { toolArgs = {}; }
-          const detail = toolDetailStr(tc.function.name, toolArgs);
-          const msgId = toolCallMsgIds[idx];
-          if (msgId) store.updateMessage(msgId, { detail, status: 'running' });
-        });
-
-        const toolPromises = toolCalls.map(async (toolCall, i) => {
-          const toolName = toolCall.function.name;
-          let toolArgs;
-          try { toolArgs = JSON.parse(toolCall.function.arguments); } catch { toolArgs = {}; }
-          const detail = toolDetailStr(toolName, toolArgs);
-          const callStart = Date.now();
-          const msgId = toolCallMsgIds[sortedIndices[i]];
-
-          const result = await executeTool(toolName, toolArgs, (partial) => {
-            if (msgId) store.updateMessage(msgId, { output: partial });
-          });
-          const success = !result.startsWith('Error');
-          const elapsed = Date.now() - callStart;
-
-          session.toolCallCount++;
-          turnToolCalls++;
-
-          if (msgId) {
-            store.updateMessage(msgId, {
-              detail,
-              status: success ? 'done' : 'error',
-              success,
-              elapsed,
-              output: result,
-            });
-          }
-
-          // Show diff for edit operations
-          if ((toolName === 'Edit' || toolName === 'Patch') && success) {
-            store.addMessage({ role: 'diff', filename: toolArgs.path, content: result });
-          }
-
-          return { id: toolCall.id, result };
-        });
-
-        const toolResults = await Promise.all(toolPromises);
-
-        for (const { id, result } of toolResults) {
-          messages.push({ role: 'tool', tool_call_id: id, content: result });
-        }
-
-        if (finishReason === 'stop') break;
-        displayContent = '';
-        continue;
-      }
-
-      // No tool calls — final text response
-      if (fullContent) {
-        const cleanedContent = parsedContent.trim() || fullContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
-        if (cleanedContent) {
-          store.finishStreaming({ role: 'assistant', content: cleanedContent });
-        } else {
-          store.clearStreaming();
-        }
-        session.conversationHistory.push({ role: 'assistant', content: cleanedContent || fullContent });
-      } else {
-        store.clearStreaming();
-      }
-      break;
-    }
-
-    if (iterations >= MAX_TOOL_ITERATIONS) {
-      store.addMessage({ role: 'system', content: `⚠ Reached maximum tool iterations (${MAX_TOOL_ITERATIONS}). Stopping.` });
-    }
-
-    session.totalTokens += turnTokens;
-
-    // Auto-delegate to CodeReview for code changes
-    if (session.filesModified.size > 0) {
-      const reviewPrompt = `User request: ${userInput}\n\n${turnTokens > 0 ? `Processed with ${turnTokens} tokens and ${turnToolCalls} tool calls.` : ''}`;
-
-      if (mode === 'max') {
-        // MAX mode: Multi-perspective code review
-        const reviewId = store.addMessage({ role: 'system', content: 'Multi-perspective code review...', label: '📋 Code Review (MAX)' });
-        try {
-          const reviewResult = await executeTool('CodeReviewMulti', { prompt: reviewPrompt }, (partial) => {
-            store.updateMessage(reviewId, { content: partial, label: '📋 Code Review (MAX)' });
-          });
-          store.updateMessage(reviewId, { content: reviewResult, label: '📋 Code Review (MAX)' });
-          session.conversationHistory.push({
-            role: 'assistant',
-            content: `\n\n--- Multi-Perspective Code Review ---\n${reviewResult}`,
-          });
-        } catch (err) {
-          store.updateMessage(reviewId, { content: `Multi-review failed: ${err.message}` });
-        }
-      } else if (mode !== 'lite') {
-        // Default mode: Single code review
-        const reviewId = store.addMessage({ role: 'system', content: 'Reviewing code changes...', label: '📋 Code Review' });
-        try {
-          const reviewResult = await executeTool('CodeReview', { prompt: reviewPrompt }, (partial) => {
-            store.updateMessage(reviewId, { content: partial, label: '📋 Code Review' });
-          });
-          store.updateMessage(reviewId, { content: reviewResult, label: '📋 Code Review' });
-          session.conversationHistory.push({
-            role: 'assistant',
-            content: `\n\n--- Code Review ---\n${reviewResult}`,
-          });
-        } catch (err) {
-          store.updateMessage(reviewId, { content: `Code review failed: ${err.message}` });
-        }
-      }
-      // Lite mode: skip code review entirely
-    }
-  } catch (err) {
-    store.clearStreaming();
-    let errorMsg = `Error: ${err.message}`;
-    if (err.status) {
-      errorMsg += `\nStatus: ${err.status}`;
-    }
-    if (!process.env.NVIDIA_API_KEY) {
-      errorMsg += '\nSet the NVIDIA_API_KEY environment variable with your API key from build.nvidia.com';
-    }
-    store.addMessage({ role: 'system', content: errorMsg });
-  }
-
-  store.addMessage({ role: 'divider' });
-  isProcessing = false;
-  store.setState({ isProcessing: false });
-}
-
-module.exports = {
-  handleUserInput,
-  getIsProcessing,
-};

package/src/app.jsx

@@ -1,96 +0,0 @@
-import { useCallback } from 'react';
-import { useKeyboard } from '@opentui/react';
-import { useStore } from './hooks/useStore.js';
-import { setState, addMessage, clearMessages, getRenderer } from './store.js';
-import { session } from './config.js';
-import { handleUserInput } from './agent.js';
-import { handleSlashCommand } from './commands.js';
-import Header from './components/Header.jsx';
-import Divider from './components/Divider.jsx';
-import ChatArea from './components/ChatArea.jsx';
-import InputBar from './components/InputBar.jsx';
-import StatusBar from './components/StatusBar.jsx';
-import HelpModal from './components/HelpModal.jsx';
-
-function exitApp() {
-  const renderer = getRenderer();
-  if (renderer) renderer.destroy();
-
-  const elapsed = ((Date.now() - session.startTime) / 1000 / 60).toFixed(1);
-  const parts = [
-    `${elapsed} min`,
-    `${session.turnCount} turns`,
-    `${session.toolCallCount} tool calls`,
-    `${session.totalTokens.toLocaleString()} tokens`,
-    `$${session.totalCost.toFixed(4)}`,
-  ];
-  if (session.filesModified.size > 0) parts.push(`${session.filesModified.size} files modified`);
-  if (session.commandsRun.length > 0) parts.push(`${session.commandsRun.length} commands`);
-
-  console.log(`\n  Session: ${parts.join(' · ')}\n`);
-  console.log('  Goodbye! ✦\n');
-  process.exit(0);
-}
-
-export default function App() {
-  const state = useStore();
-
-  useKeyboard((key) => {
-    if (key.ctrl && key.name === 'c') {
-      exitApp();
-    }
-  });
-
-  const handleInput = useCallback(async (value) => {
-    if (value === 'exit' || value === 'quit') {
-      exitApp();
-      return;
-    }
-
-    if (value.startsWith('/')) {
-      const result = await handleSlashCommand(value);
-      if (result?.action === 'quit') {
-        exitApp();
-      }
-      return;
-    }
-
-    handleUserInput(value).catch(err => {
-      addMessage({ role: 'system', content: `Error: ${err.message}` });
-      setState({ isProcessing: false });
-    });
-  }, []);
-
-  const handleHelpCommand = useCallback((cmd) => {
-    if (cmd) {
-      handleSlashCommand(cmd).then(result => {
-        if (result?.action === 'quit') exitApp();
-      });
-    }
-  }, []);
-
-  return (
-    <box style={{ flexDirection: 'column', flexGrow: 1 }}>
-      <Header />
-      <Divider />
-      <ChatArea
-        messages={state.messages}
-        streamingContent={state.streamingContent}
-        streamingThinking={state.streamingThinking}
-        isProcessing={state.isProcessing}
-      />
-      <Divider />
-      <StatusBar isProcessing={state.isProcessing} />
-      <InputBar
-        disabled={state.isProcessing || state.showHelp}
-        onSubmit={handleInput}
-      />
-      {state.showHelp ? (
-        <HelpModal
-          onClose={() => setState({ showHelp: false })}
-          onCommand={handleHelpCommand}
-        />
-      ) : null}
-    </box>
-  );
-}