nex-code 0.3.4 → 0.3.7

package/cli/mcp.js

@@ -1,284 +0,0 @@
-/**
- * cli/mcp.js — MCP (Model Context Protocol) Client
- * Discovers and invokes tools from external MCP servers via JSON-RPC over stdio.
- */
-
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-// Active MCP server connections
-const activeServers = new Map();
-
-function getConfigPath() {
-  return path.join(process.cwd(), '.nex', 'config.json');
-}
-
-/**
- * Load MCP server configurations from .nex/config.json
- * @returns {Object<string, {command: string, args?: string[], env?: Object}>}
- */
-function loadMCPConfig() {
-  const configPath = getConfigPath();
-  if (!fs.existsSync(configPath)) return {};
-  try {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    return config.mcpServers || {};
-  } catch {
-    return {};
-  }
-}
-
-/**
- * Send a JSON-RPC request to an MCP server process
- * @param {import('child_process').ChildProcess} proc
- * @param {string} method
- * @param {Object} params
- * @param {number} timeout — ms
- * @returns {Promise<Object>}
- */
-function sendRequest(proc, method, params = {}, timeout = 10000) {
-  return new Promise((resolve, reject) => {
-    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-    const request = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
-
-    let buffer = '';
-    const timer = setTimeout(() => {
-      cleanup();
-      reject(new Error(`MCP request timeout: ${method}`));
-    }, timeout);
-
-    function onData(data) {
-      buffer += data.toString();
-      const lines = buffer.split('\n');
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const msg = JSON.parse(line);
-          if (msg.id === id) {
-            cleanup();
-            if (msg.error) {
-              reject(new Error(`MCP error: ${msg.error.message || JSON.stringify(msg.error)}`));
-            } else {
-              resolve(msg.result);
-            }
-            return;
-          }
-        } catch {
-          // Not valid JSON yet, continue buffering
-        }
-      }
-      // Keep only the last incomplete line
-      buffer = lines[lines.length - 1] || '';
-    }
-
-    function cleanup() {
-      clearTimeout(timer);
-      proc.stdout.removeListener('data', onData);
-    }
-
-    proc.stdout.on('data', onData);
-    try {
-      proc.stdin.write(request);
-    } catch (e) {
-      cleanup();
-      reject(new Error(`MCP write failed: ${e.message}`));
-    }
-  });
-}
-
-/**
- * Connect to an MCP server
- * @param {string} name
- * @param {{command: string, args?: string[], env?: Object}} config
- * @returns {Promise<{name: string, tools: Array}>}
- */
-async function connectServer(name, config) {
-  if (activeServers.has(name)) {
-    return activeServers.get(name);
-  }
-
-  // Allowlist safe env vars to prevent API key leakage
-  const SAFE_ENV_KEYS = ['PATH', 'HOME', 'USER', 'SHELL', 'LANG', 'TERM', 'NODE_ENV'];
-  const filteredEnv = {};
-  for (const key of SAFE_ENV_KEYS) {
-    if (process.env[key]) filteredEnv[key] = process.env[key];
-  }
-  const proc = spawn(config.command, config.args || [], {
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...filteredEnv, ...(config.env || {}) },
-  });
-
-  const server = { name, proc, tools: [], config };
-
-  // Initialize with JSON-RPC
-  try {
-    await sendRequest(proc, 'initialize', {
-      protocolVersion: '2024-11-05',
-      capabilities: {},
-      clientInfo: { name: 'nex-code', version: '0.2.0' },
-    });
-
-    // Discover tools
-    const toolsResult = await sendRequest(proc, 'tools/list', {});
-    server.tools = (toolsResult && toolsResult.tools) || [];
-
-    activeServers.set(name, server);
-    return server;
-  } catch (err) {
-    proc.kill();
-    throw new Error(`Failed to connect MCP server '${name}': ${err.message}`);
-  }
-}
-
-/**
- * Disconnect an MCP server
- * @param {string} name
- */
-function disconnectServer(name) {
-  const server = activeServers.get(name);
-  if (!server) return false;
-  try {
-    server.proc.kill();
-  } catch {
-    // Process may already be dead
-  }
-  activeServers.delete(name);
-  return true;
-}
-
-/**
- * Disconnect all MCP servers
- */
-function disconnectAll() {
-  for (const [name] of activeServers) {
-    disconnectServer(name);
-  }
-}
-
-/**
- * Call a tool on an MCP server
- * @param {string} serverName
- * @param {string} toolName
- * @param {Object} args
- * @returns {Promise<string>}
- */
-async function callTool(serverName, toolName, args = {}) {
-  const server = activeServers.get(serverName);
-  if (!server) throw new Error(`MCP server not connected: ${serverName}`);
-
-  const result = await sendRequest(server.proc, 'tools/call', {
-    name: toolName,
-    arguments: args,
-  });
-
-  // MCP returns content array — extract text
-  if (result && Array.isArray(result.content)) {
-    return result.content
-      .filter((c) => c.type === 'text')
-      .map((c) => c.text)
-      .join('\n');
-  }
-  return JSON.stringify(result);
-}
-
-/**
- * Get all tools from all connected MCP servers
- * @returns {Array<{server: string, name: string, description: string, inputSchema: Object}>}
- */
-function getAllTools() {
-  const tools = [];
-  for (const [serverName, server] of activeServers) {
-    for (const tool of server.tools) {
-      tools.push({
-        server: serverName,
-        name: tool.name,
-        description: tool.description || '',
-        inputSchema: tool.inputSchema || { type: 'object', properties: {} },
-      });
-    }
-  }
-  return tools;
-}
-
-/**
- * Convert MCP tools to OpenAI-style tool definitions for the LLM
- * @returns {Array}
- */
-function getMCPToolDefinitions() {
-  return getAllTools().map((t) => ({
-    type: 'function',
-    function: {
-      name: `mcp_${t.server}_${t.name}`,
-      description: `[MCP:${t.server}] ${t.description}`,
-      parameters: t.inputSchema,
-    },
-  }));
-}
-
-/**
- * Check if a tool call is an MCP tool and route it
- * @param {string} fnName
- * @param {Object} args
- * @returns {Promise<string|null>} — null if not an MCP tool
- */
-async function routeMCPCall(fnName, args) {
-  if (!fnName.startsWith('mcp_')) return null;
-
-  const parts = fnName.substring(4).split('_');
-  if (parts.length < 2) return null;
-
-  const serverName = parts[0];
-  const toolName = parts.slice(1).join('_');
-
-  return callTool(serverName, toolName, args);
-}
-
-/**
- * List configured MCP servers and their status
- * @returns {Array<{name: string, command: string, connected: boolean, toolCount: number}>}
- */
-function listServers() {
-  const config = loadMCPConfig();
-  return Object.entries(config).map(([name, conf]) => {
-    const server = activeServers.get(name);
-    return {
-      name,
-      command: conf.command,
-      connected: !!server,
-      toolCount: server ? server.tools.length : 0,
-    };
-  });
-}
-
-/**
- * Connect all configured MCP servers
- * @returns {Promise<Array<{name: string, tools: number, error?: string}>>}
- */
-async function connectAll() {
-  const config = loadMCPConfig();
-  const results = [];
-  for (const [name, conf] of Object.entries(config)) {
-    try {
-      const server = await connectServer(name, conf);
-      results.push({ name, tools: server.tools.length });
-    } catch (err) {
-      results.push({ name, tools: 0, error: err.message });
-    }
-  }
-  return results;
-}
-
-module.exports = {
-  loadMCPConfig,
-  sendRequest,
-  connectServer,
-  disconnectServer,
-  disconnectAll,
-  callTool,
-  getAllTools,
-  getMCPToolDefinitions,
-  routeMCPCall,
-  listServers,
-  connectAll,
-};

package/cli/memory.js

@@ -1,170 +0,0 @@
-/**
- * cli/memory.js — Project Memory
- * Persistent key-value memory stored in .nex/memory/
- * Also loads NEX.md from project root for project-level instructions
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-function getMemoryDir() {
-  return path.join(process.cwd(), '.nex', 'memory');
-}
-
-function getMemoryFile() {
-  return path.join(getMemoryDir(), 'memory.json');
-}
-
-function getNexMdPath() {
-  return path.join(process.cwd(), 'NEX.md');
-}
-
-function getGlobalNexMdPath() {
-  return path.join(os.homedir(), '.nex', 'NEX.md');
-}
-
-function ensureDir() {
-  const dir = getMemoryDir();
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-function readMemoryFile() {
-  const file = getMemoryFile();
-  if (!fs.existsSync(file)) return {};
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf-8'));
-  } catch {
-    return {};
-  }
-}
-
-function writeMemoryFile(data) {
-  ensureDir();
-  fs.writeFileSync(getMemoryFile(), JSON.stringify(data, null, 2), 'utf-8');
-}
-
-/**
- * Remember a key-value pair
- * @param {string} key
- * @param {string} value
- */
-function remember(key, value) {
-  const data = readMemoryFile();
-  data[key] = {
-    value,
-    updatedAt: new Date().toISOString(),
-  };
-  writeMemoryFile(data);
-}
-
-/**
- * Recall a value by key
- * @param {string} key
- * @returns {string|null}
- */
-function recall(key) {
-  const data = readMemoryFile();
-  if (data[key]) return data[key].value;
-  return null;
-}
-
-/**
- * Forget (delete) a memory
- * @param {string} key
- * @returns {boolean}
- */
-function forget(key) {
-  const data = readMemoryFile();
-  if (!(key in data)) return false;
-  delete data[key];
-  writeMemoryFile(data);
-  return true;
-}
-
-/**
- * List all memories
- * @returns {Array<{ key, value, updatedAt }>}
- */
-function listMemories() {
-  const data = readMemoryFile();
-  return Object.entries(data).map(([key, entry]) => ({
-    key,
-    value: entry.value,
-    updatedAt: entry.updatedAt,
-  }));
-}
-
-/**
- * Load global NEX.md from ~/.nex/NEX.md (if it exists)
- * @returns {string} — Contents of global NEX.md or empty string
- */
-function loadGlobalInstructions() {
-  const globalMd = getGlobalNexMdPath();
-  if (!fs.existsSync(globalMd)) return '';
-  try {
-    return fs.readFileSync(globalMd, 'utf-8').trim();
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Load NEX.md from project root (if it exists)
- * @returns {string} — Contents of NEX.md or empty string
- */
-function loadProjectInstructions() {
-  const nexMd = getNexMdPath();
-  if (!fs.existsSync(nexMd)) return '';
-  try {
-    return fs.readFileSync(nexMd, 'utf-8').trim();
-  } catch {
-    return '';
-  }
-}
-
-/**
- * Get memory context for system prompt inclusion
- * Returns formatted string with memories + NEX.md content
- * @returns {string}
- */
-function getMemoryContext() {
-  const parts = [];
-
-  // Load global NEX.md (~/.nex/NEX.md)
-  const globalInstructions = loadGlobalInstructions();
-  if (globalInstructions) {
-    parts.push(`GLOBAL INSTRUCTIONS (~/.nex/NEX.md):\n${globalInstructions}`);
-  }
-
-  // Load project NEX.md
-  const instructions = loadProjectInstructions();
-  if (instructions) {
-    parts.push(`PROJECT INSTRUCTIONS (NEX.md):\n${instructions}`);
-  }
-
-  // Load memories
-  const memories = listMemories();
-  if (memories.length > 0) {
-    const memStr = memories.map((m) => `  ${m.key}: ${m.value}`).join('\n');
-    parts.push(`PROJECT MEMORY:\n${memStr}`);
-  }
-
-  return parts.join('\n\n');
-}
-
-module.exports = {
-  remember,
-  recall,
-  forget,
-  listMemories,
-  loadGlobalInstructions,
-  loadProjectInstructions,
-  getMemoryContext,
-  // exported for testing
-  _getMemoryDir: getMemoryDir,
-  _getMemoryFile: getMemoryFile,
-  _getGlobalNexMdPath: getGlobalNexMdPath,
-};

package/cli/ollama.js

@@ -1,130 +0,0 @@
-/**
- * cli/ollama.js — Ollama API Client (Backward-compatible wrapper)
- *
- * This module now delegates to the provider system (cli/providers/).
- * Exports the same API for backward compatibility.
- */
-
-const registry = require('./providers/registry');
-
-const MODELS = {
-  'kimi-k2.5': { id: 'kimi-k2.5', name: 'Kimi K2.5', max_tokens: 16384 },
-  'qwen3-coder:480b': { id: 'qwen3-coder:480b', name: 'Qwen3 Coder 480B', max_tokens: 16384 },
-};
-
-function getActiveModel() {
-  return registry.getActiveModel();
-}
-
-function setActiveModel(name) {
-  return registry.setActiveModel(name);
-}
-
-function getModelNames() {
-  return registry.getModelNames();
-}
-
-/**
- * Parse tool call arguments with fallback strategies.
- * This is a utility function, not provider-specific.
- */
-function parseToolArgs(raw) {
-  if (!raw) return null;
-  if (typeof raw === 'object') return raw;
-  try {
-    return JSON.parse(raw);
-  } catch {
-    /* continue */
-  }
-  try {
-    const fixed = raw.replace(/,\s*([}\]])/g, '$1').replace(/'/g, '"');
-    return JSON.parse(fixed);
-  } catch {
-    /* continue */
-  }
-  const match = raw.match(/\{[\s\S]*\}/);
-  if (match) {
-    try {
-      return JSON.parse(match[0]);
-    } catch {
-      /* continue */
-    }
-  }
-
-  // Strategy 4: Fix unquoted keys (common in OS models)
-  try {
-    const fixedKeys = raw.replace(/(\{|,)\s*([a-zA-Z_]\w*)\s*:/g, '$1"$2":');
-    return JSON.parse(fixedKeys);
-  } catch {
-    /* continue */
-  }
-
-  // Strategy 5: Strip markdown code fences (DeepSeek R1, Llama wrap JSON in ```json)
-  const fenceMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
-  if (fenceMatch) {
-    try {
-      return JSON.parse(fenceMatch[1].trim());
-    } catch {
-      /* give up */
-    }
-  }
-
-  return null;
-}
-
-/**
- * @deprecated Use providers/registry.callStream() instead.
- * Streaming call through the active provider.
- */
-async function callOllamaStream(messages, tools) {
-  const { C } = require('./ui');
-  const { Spinner } = require('./ui');
-
-  const spinner = new Spinner('Thinking...');
-  spinner.start();
-  let firstToken = true;
-  let contentStr = '';
-
-  try {
-    const result = await registry.callStream(messages, tools, {
-      onToken: (text) => {
-        if (firstToken) {
-          spinner.stop();
-          process.stdout.write(`${C.blue}`);
-          firstToken = false;
-        }
-        process.stdout.write(text);
-        contentStr += text;
-      },
-    });
-
-    if (firstToken) {
-      spinner.stop();
-    } else {
-      process.stdout.write(`${C.reset}\n`);
-    }
-
-    return result;
-  } catch (err) {
-    spinner.stop();
-    throw err;
-  }
-}
-
-/**
- * @deprecated Use providers/registry.callChat() instead.
- * Non-streaming call through the active provider.
- */
-async function callOllama(messages, tools) {
-  return registry.callChat(messages, tools);
-}
-
-module.exports = {
-  MODELS,
-  getActiveModel,
-  setActiveModel,
-  getModelNames,
-  callOllamaStream,
-  callOllama,
-  parseToolArgs,
-};

package/cli/permissions.js

@@ -1,124 +0,0 @@
-/**
- * cli/permissions.js — Tool Permission System
- * Three modes per tool: 'allow' (auto), 'ask' (confirm), 'deny' (blocked)
- */
-
-const fs = require('fs');
-const path = require('path');
-const { C } = require('./ui');
-
-// Default permissions: read ops auto, write/bash ask
-const DEFAULT_PERMISSIONS = {
-  bash: 'ask',
-  read_file: 'allow',
-  write_file: 'ask',
-  edit_file: 'ask',
-  list_directory: 'allow',
-  search_files: 'allow',
-  glob: 'allow',
-  grep: 'allow',
-  patch_file: 'ask',
-  web_fetch: 'allow',
-  web_search: 'allow',
-  ask_user: 'allow',
-  task_list: 'allow',
-  spawn_agents: 'ask',
-};
-
-let permissions = { ...DEFAULT_PERMISSIONS };
-
-/**
- * Load permissions from .nex/config.json if it exists
- */
-function loadPermissions() {
-  const configPath = path.join(process.cwd(), '.nex', 'config.json');
-  if (!fs.existsSync(configPath)) return;
-  try {
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    if (config.permissions) {
-      permissions = { ...DEFAULT_PERMISSIONS, ...config.permissions };
-    }
-  } catch {
-    // ignore corrupt config
-  }
-}
-
-/**
- * Save current permissions to .nex/config.json
- */
-function savePermissions() {
-  const configDir = path.join(process.cwd(), '.nex');
-  const configPath = path.join(configDir, 'config.json');
-
-  let config = {};
-  if (fs.existsSync(configPath)) {
-    try {
-      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    } catch {
-      config = {};
-    }
-  }
-
-  config.permissions = permissions;
-  if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}
-
-/**
- * Get permission for a tool
- * @param {string} toolName
- * @returns {'allow'|'ask'|'deny'}
- */
-function getPermission(toolName) {
-  return permissions[toolName] || 'ask';
-}
-
-/**
- * Set permission for a tool
- * @param {string} toolName
- * @param {'allow'|'ask'|'deny'} mode
- * @returns {boolean} true if valid
- */
-function setPermission(toolName, mode) {
-  if (!['allow', 'ask', 'deny'].includes(mode)) return false;
-  permissions[toolName] = mode;
-  return true;
-}
-
-/**
- * Check if a tool execution is allowed
- * @param {string} toolName
- * @returns {'allow'|'ask'|'deny'}
- */
-function checkPermission(toolName) {
-  return getPermission(toolName);
-}
-
-/**
- * List all permissions
- * @returns {Array<{ tool, mode }>}
- */
-function listPermissions() {
-  return Object.entries(permissions).map(([tool, mode]) => ({ tool, mode }));
-}
-
-/**
- * Reset permissions to defaults
- */
-function resetPermissions() {
-  permissions = { ...DEFAULT_PERMISSIONS };
-}
-
-// Load on init
-loadPermissions();
-
-module.exports = {
-  getPermission,
-  setPermission,
-  checkPermission,
-  listPermissions,
-  loadPermissions,
-  savePermissions,
-  resetPermissions,
-  DEFAULT_PERMISSIONS,
-};