upfynai-code 3.0.3 → 3.1.0

package/scripts/install-commands.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-/**
- * Upfyn-Code — Slash Command Installer
- *
- * Copies slash command .md files to ~/.claude/commands/
- * so they become available as /upfynai-* inside your AI CLI.
- *
- * Run manually: node scripts/install-commands.js
- * Or via CLI:   uc install-commands
- */
-
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const COMMANDS_SOURCE = path.join(__dirname, '..', 'commands');
-const COMMANDS_DEST = path.join(os.homedir(), '.claude', 'commands');
-
-const colors = {
-  reset: '\x1b[0m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  dim: '\x1b[2m',
-  bright: '\x1b[1m',
-};
-
-function main() {
-  console.log(`\n${colors.bright}Upfyn-Code — Installing Slash Commands${colors.reset}\n`);
-
-  // Ensure ~/.claude/commands/ exists
-  if (!fs.existsSync(COMMANDS_DEST)) {
-    fs.mkdirSync(COMMANDS_DEST, { recursive: true });
-    console.log(`${colors.green}✅${colors.reset} Created ${colors.dim}${COMMANDS_DEST}${colors.reset}`);
-  }
-
-  // Read all .md files from commands source
-  if (!fs.existsSync(COMMANDS_SOURCE)) {
-    console.error(`${colors.yellow}⚠️${colors.reset}  Commands source not found: ${COMMANDS_SOURCE}`);
-    process.exit(0);
-  }
-
-  const files = fs.readdirSync(COMMANDS_SOURCE).filter(f => f.endsWith('.md'));
-
-  if (files.length === 0) {
-    console.log(`${colors.yellow}⚠️${colors.reset}  No command files found in ${COMMANDS_SOURCE}`);
-    process.exit(0);
-  }
-
-  let installed = 0;
-  let updated = 0;
-
-  for (const file of files) {
-    const src = path.join(COMMANDS_SOURCE, file);
-    const dest = path.join(COMMANDS_DEST, file);
-
-    const existed = fs.existsSync(dest);
-    fs.copyFileSync(src, dest);
-
-    if (existed) {
-      updated++;
-      console.log(`${colors.cyan}🔄${colors.reset} Updated  /${file.replace('.md', '')}`);
-    } else {
-      installed++;
-      console.log(`${colors.green}✅${colors.reset} Installed /${file.replace('.md', '')}`);
-    }
-  }
-
-  console.log(`\n${colors.bright}Done!${colors.reset} ${installed} installed, ${updated} updated`);
-  console.log(`${colors.dim}Commands are now available in your AI CLI${colors.reset}`);
-  console.log(`${colors.dim}Try: /upfynai to start the web UI${colors.reset}\n`);
-}
-
-main();

package/server/agent-loop.js

@@ -1,242 +0,0 @@
-/**
- * Agent Loop: Stream → Tool Execute → Loop
- * Ported from opencode-ai/opencode internal/llm/agent/agent.go
- *
- * For cloud mode (BYOK): when the AI returns tool_use calls, execute them
- * server-side (or via relay), append results, and loop until no more tool calls.
- *
- * This implements the core agentic loop pattern:
- *   1. Stream response from LLM
- *   2. Collect tool calls from the response
- *   3. Execute tools (file read, shell, etc.)
- *   4. Append tool results to message history
- *   5. Loop back to step 1 until AI finishes without tool calls
- */
-
-import { streamChat, calculateCost } from './provider-factory.js';
-import { checkNeedsCompact, buildSummarizationPrompt, compactMessages } from './auto-compact.js';
-
-const MAX_TOOL_LOOPS = 25; // Safety limit to prevent infinite loops
-
-/**
- * Available server-side tools (opencode pattern: tool registry per agent type)
- * These are tools the AI can call during the agent loop.
- * For relay mode, tool execution is forwarded to the CLI.
- * For cloud mode, tools execute on the server or sandbox.
- */
-const TOOLS_SCHEMA = [
-  {
-    type: 'function',
-    function: {
-      name: 'read_file',
-      description: 'Read the contents of a file',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: { type: 'string', description: 'File path to read' },
-        },
-        required: ['path'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'write_file',
-      description: 'Write content to a file',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: { type: 'string', description: 'File path to write' },
-          content: { type: 'string', description: 'File content' },
-        },
-        required: ['path', 'content'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'run_command',
-      description: 'Execute a shell command',
-      parameters: {
-        type: 'object',
-        properties: {
-          command: { type: 'string', description: 'Shell command to run' },
-          cwd: { type: 'string', description: 'Working directory (optional)' },
-        },
-        required: ['command'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'list_files',
-      description: 'List files in a directory',
-      parameters: {
-        type: 'object',
-        properties: {
-          path: { type: 'string', description: 'Directory path' },
-          pattern: { type: 'string', description: 'Glob pattern (optional)' },
-        },
-        required: ['path'],
-      },
-    },
-  },
-  {
-    type: 'function',
-    function: {
-      name: 'search_files',
-      description: 'Search for text in files',
-      parameters: {
-        type: 'object',
-        properties: {
-          query: { type: 'string', description: 'Search query (regex)' },
-          path: { type: 'string', description: 'Directory to search in' },
-        },
-        required: ['query'],
-      },
-    },
-  },
-];
-
-/**
- * Run the agent loop (opencode pattern: processGeneration).
- *
- * @param {string} model - LLM model name
- * @param {Array} messages - Message history
- * @param {object} options - { apiKey, systemPrompt, onEvent, executeTool, maxLoops }
- * @returns {Promise<{ messages, usage, cost }>}
- *
- * options.onEvent(event) - Called for each streaming event:
- *   { type: 'content_delta', content: '...' }
- *   { type: 'tool_call', name: '...', input: {...} }
- *   { type: 'tool_result', name: '...', output: '...' }
- *   { type: 'complete' }
- *   { type: 'error', error: '...' }
- *
- * options.executeTool(name, input) - Executes a tool, returns string result.
- *   If not provided, tool calls are skipped (text-only mode).
- */
-export async function runAgentLoop(model, messages, options = {}) {
-  const {
-    apiKey,
-    systemPrompt,
-    onEvent = () => {},
-    executeTool,
-    maxLoops = MAX_TOOL_LOOPS,
-  } = options;
-
-  let totalUsage = { promptTokens: 0, completionTokens: 0 };
-  let loopCount = 0;
-  let currentMessages = [...messages];
-
-  // Add system prompt if provided
-  if (systemPrompt && (!currentMessages.length || currentMessages[0].role !== 'system')) {
-    currentMessages.unshift({ role: 'system', content: systemPrompt });
-  }
-
-  while (loopCount < maxLoops) {
-    loopCount++;
-
-    // Check if we need auto-compact (opencode pattern: summarize at 85% context)
-    const compactCheck = checkNeedsCompact(currentMessages, model);
-    if (compactCheck.needsCompact) {
-      onEvent({ type: 'system', message: 'Compacting conversation context...' });
-      // In a real implementation, this would call the LLM to summarize
-      // For now, just trim old messages
-      if (currentMessages.length > 10) {
-        const recent = currentMessages.slice(-6);
-        currentMessages = [currentMessages[0], ...recent]; // keep system + recent
-      }
-    }
-
-    // Stream response from LLM
-    let assistantContent = '';
-    let toolCalls = [];
-    let currentToolCall = null;
-
-    try {
-      for await (const event of streamChat(model, currentMessages, {
-        apiKey,
-        tools: executeTool ? TOOLS_SCHEMA : undefined,
-      })) {
-        if (event.type === 'content_delta') {
-          assistantContent += event.content;
-          onEvent({ type: 'content_delta', content: event.content });
-        } else if (event.type === 'tool_call_start') {
-          currentToolCall = { name: event.name, id: event.id, input: '' };
-        } else if (event.type === 'tool_call_delta') {
-          if (currentToolCall) currentToolCall.input += event.content;
-        } else if (event.type === 'tool_call_end') {
-          if (currentToolCall) {
-            try { currentToolCall.input = JSON.parse(currentToolCall.input); } catch {}
-            toolCalls.push(currentToolCall);
-            onEvent({ type: 'tool_call', name: currentToolCall.name, input: currentToolCall.input });
-            currentToolCall = null;
-          }
-        } else if (event.type === 'usage') {
-          totalUsage.promptTokens += event.promptTokens;
-          totalUsage.completionTokens += event.completionTokens;
-        } else if (event.type === 'complete') {
-          break;
-        }
-      }
-    } catch (err) {
-      onEvent({ type: 'error', error: err.message });
-      break;
-    }
-
-    // Append assistant message
-    const assistantMsg = { role: 'assistant', content: assistantContent };
-    if (toolCalls.length > 0) {
-      assistantMsg.tool_calls = toolCalls.map(tc => ({
-        id: tc.id || `call_${Date.now()}`,
-        type: 'function',
-        function: { name: tc.name, arguments: JSON.stringify(tc.input) },
-      }));
-    }
-    currentMessages.push(assistantMsg);
-
-    // If no tool calls, we're done (opencode pattern: finish reason != ToolUse → return)
-    if (toolCalls.length === 0 || !executeTool) {
-      onEvent({ type: 'complete' });
-      break;
-    }
-
-    // Execute tools and append results (opencode pattern: tool execution loop)
-    for (const tc of toolCalls) {
-      let result;
-      try {
-        result = await executeTool(tc.name, tc.input);
-        onEvent({ type: 'tool_result', name: tc.name, output: result });
-      } catch (err) {
-        result = `Error: ${err.message}`;
-        onEvent({ type: 'tool_result', name: tc.name, output: result, isError: true });
-      }
-
-      currentMessages.push({
-        role: 'tool',
-        tool_call_id: tc.id || `call_${Date.now()}`,
-        content: typeof result === 'string' ? result : JSON.stringify(result),
-      });
-    }
-
-    // Loop back to get next response (step 5 → step 1)
-  }
-
-  if (loopCount >= maxLoops) {
-    onEvent({ type: 'error', error: `Agent loop exceeded maximum iterations (${maxLoops})` });
-  }
-
-  const cost = calculateCost(model, totalUsage.promptTokens, totalUsage.completionTokens);
-
-  return {
-    messages: currentMessages,
-    usage: totalUsage,
-    costCents: cost,
-  };
-}
-
-export { TOOLS_SCHEMA };

package/server/auto-compact.js

@@ -1,99 +0,0 @@
-/**
- * Auto-Compact Context Summarization
- * Ported from opencode-ai/opencode internal/llm/agent/agent.go (summarize logic)
- *
- * When a conversation approaches the context window limit, this module
- * summarizes the conversation and returns a condensed version.
- *
- * Used for BYOK cloud mode (OpenRouter, direct API calls) where the server
- * manages the message history. For relay mode, the CLI handles context internally.
- */
-
-// Model context windows (opencode pattern: models.go ContextWindow)
-const CONTEXT_WINDOWS = {
-  'claude-sonnet-4-20250514': 200000,
-  'claude-opus-4-20250514': 200000,
-  'claude-haiku-4-5-20251001': 200000,
-  'gpt-4o': 128000,
-  'gpt-4o-mini': 128000,
-  'o1': 200000,
-  'o3-mini': 200000,
-  'deepseek-chat': 64000,
-  'deepseek-reasoner': 64000,
-};
-
-// Rough token estimation (~4 chars per token)
-function estimateTokens(text) {
-  return Math.ceil((text || '').length / 4);
-}
-
-/**
- * Check if a message history needs compaction.
- * @param {Array} messages - Array of { role, content } messages
- * @param {string} model - Model name
- * @param {number} threshold - Fraction of context window to trigger (default 0.85)
- * @returns {{ needsCompact: boolean, estimatedTokens: number, contextWindow: number }}
- */
-export function checkNeedsCompact(messages, model, threshold = 0.85) {
-  const contextWindow = CONTEXT_WINDOWS[model] || 128000;
-  const totalTokens = messages.reduce((sum, m) => sum + estimateTokens(m.content), 0);
-  return {
-    needsCompact: totalTokens > contextWindow * threshold,
-    estimatedTokens: totalTokens,
-    contextWindow,
-  };
-}
-
-/**
- * Build a summarization prompt for compacting conversation history.
- * Returns messages array suitable for sending to an LLM.
- *
- * @param {Array} messages - Full message history
- * @param {string} systemPrompt - Original system prompt
- * @returns {Array} Messages for the summarization call
- */
-export function buildSummarizationPrompt(messages, systemPrompt = '') {
-  // Take the conversation content and ask for a summary
-  // (opencode pattern: AgentSummarizer with dedicated prompt)
-  const conversationText = messages
-    .map(m => `[${m.role}]: ${(m.content || '').slice(0, 2000)}`)
-    .join('\n\n');
-
-  return [
-    {
-      role: 'system',
-      content: `You are a conversation summarizer. Summarize the following conversation between a user and an AI coding assistant. Focus on:
-1. Key decisions made
-2. Files modified and why
-3. Current state of the task
-4. Any unresolved issues or next steps
-
-Keep the summary concise but preserve all critical technical details. The summary will be used as context for continuing the conversation.`,
-    },
-    {
-      role: 'user',
-      content: `Summarize this conversation:\n\n${conversationText}`,
-    },
-  ];
-}
-
-/**
- * Compact a message history by replacing old messages with a summary.
- * The summary becomes the first message, preserving the most recent messages.
- *
- * @param {Array} messages - Full message history
- * @param {string} summary - Generated summary text
- * @param {number} keepRecent - Number of recent messages to keep verbatim (default 4)
- * @returns {Array} Compacted messages
- */
-export function compactMessages(messages, summary, keepRecent = 4) {
-  const recentMessages = messages.slice(-keepRecent);
-
-  return [
-    {
-      role: 'system',
-      content: `[Conversation Summary]\n${summary}\n\n[The conversation continues below with the most recent messages]`,
-    },
-    ...recentMessages,
-  ];
-}