junecoder 1.0.0

package/executor.mjs

@@ -0,0 +1,207 @@
+/**
+ * Tool execution engine — two-phase tool call processing.
+ *
+ * Phase 1: parse + validate + permission check (serial)
+ * Phase 2: execute parallel-ready tools together, serial tools one-by-one
+ */
+import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import {
+  TOOL_RESULT_OFFLOAD_LIMIT,
+  TOOL_RESULT_PREVIEW,
+} from './agent.mjs';
+
+// ─── executeToolCalls ─────────────────────────────────────────────────────────
+
+/**
+ * Execute a batch of tool calls from the LLM.
+ *
+ * @param {object} agent - agent instance
+ * @param {Map<string, object>} toolByName - tool name → tool definition
+ * @param {object[]} toolCalls - LLM tool_calls [{id, function:{name,arguments}}]
+ * @param {object} callbacks - { onToolCall, onToolOutput, onPermissionRequest }
+ * @param {number} depth - nesting depth (0 = top-level)
+ * @param {AbortSignal} [signal]
+ * @returns {Promise<object[]>} results in original toolCalls order [{id, name, output, error?}]
+ */
+export async function executeToolCalls(agent, toolByName, toolCalls, callbacks, depth, signal) {
+  if (!toolCalls || toolCalls.length === 0) return [];
+
+  const cb = callbacks || {};
+
+  // ── Phase 1: Prepare (serial) ──────────────────────────────────────────
+  const prepared = [];
+
+  for (const tc of toolCalls) {
+    const id = tc.id || `call_${prepared.length}`;
+    const name = tc.function?.name || '';
+    let args = {};
+
+    // Parse arguments
+    try {
+      args = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
+    } catch {
+      prepared.push({ id, name, error: `Invalid JSON arguments: ${tc.function?.arguments?.slice(0, 100)}` });
+      continue;
+    }
+
+    // Check tool exists
+    const tool = toolByName.get(name);
+    if (!tool) {
+      prepared.push({ id, name, error: `Unknown tool: ${name}` });
+      continue;
+    }
+
+    // Plan mode: reject non-readonly tools
+    if (agent.planMode && !tool.readonly) {
+      prepared.push({
+        id,
+        name,
+        denied: true,
+        output: `Tool "${name}" is not allowed in plan mode (read-only tools only). Exit plan mode first.`,
+      });
+      continue;
+    }
+
+    // Permission request for non-readonly tools
+    let permissionDenied = false;
+    if (!tool.readonly && cb.onPermissionRequest) {
+      try {
+        const allowed = await cb.onPermissionRequest(tool, args);
+        if (!allowed) {
+          permissionDenied = true;
+        }
+      } catch {
+        permissionDenied = true;
+      }
+    }
+
+    if (permissionDenied) {
+      prepared.push({
+        id,
+        name,
+        denied: true,
+        output: `Permission denied for "${name}".`,
+      });
+      continue;
+    }
+
+    prepared.push({ id, name, tool, args });
+  }
+
+  // ── Phase 2: Execute (parallel groups, then serial) ────────────────────
+
+  const results = new Array(toolCalls.length).fill(null);
+
+  // Assemble results by original index
+  const preparedWithIndex = prepared.map((p, i) => ({ ...p, _idx: i }));
+
+  // Group: parallel (readonly or explicit parallel) vs serial
+  const parallelItems = [];
+  const serialItems = [];
+
+  for (const item of preparedWithIndex) {
+    if (item.error || item.denied) {
+      // Already resolved in phase 1
+      results[item._idx] = {
+        id: item.id,
+        name: item.name,
+        output: item.error ? null : item.output,
+        error: item.error || null,
+        denied: item.denied || false,
+      };
+    } else if (item.tool.parallel === true || item.tool.readonly) {
+      parallelItems.push(item);
+    } else {
+      serialItems.push(item);
+    }
+  }
+
+  // Execute parallel group
+  if (parallelItems.length > 0) {
+    const parallelResults = await Promise.all(
+      parallelItems.map((item) => runOne(agent, item, cb, signal)),
+    );
+    for (let i = 0; i < parallelItems.length; i++) {
+      results[parallelItems[i]._idx] = parallelResults[i];
+    }
+  }
+
+  // Execute serial group one by one
+  for (const item of serialItems) {
+    try {
+      // Single-item parallel-ish (but in a serial loop)
+      const [result] = await Promise.all([runOne(agent, item, cb, signal)]);
+      results[item._idx] = result;
+    } catch {
+      results[item._idx] = {
+        id: item.id,
+        name: item.name,
+        output: null,
+        error: 'Serial execution failed',
+      };
+    }
+  }
+
+  return results.filter(Boolean);
+}
+
+// ─── runOne ───────────────────────────────────────────────────────────────────
+
+async function runOne(agent, item, callbacks, signal) {
+  const { id, name, tool, args } = item;
+
+  if (callbacks.onToolCall) {
+    try {
+      callbacks.onToolCall(name, args);
+    } catch { /* ignore callback errors */ }
+  }
+
+  let output;
+  let error = null;
+
+  try {
+    const raw = await tool.execute(args, agent, { signal });
+    output = typeof raw === 'string' ? raw : JSON.stringify(raw);
+
+    // Offload long results
+    if (output.length > TOOL_RESULT_OFFLOAD_LIMIT) {
+      output = offloadToolResult(name, output);
+    }
+  } catch (err) {
+    error = err.message || String(err);
+    output = null;
+  }
+
+  if (callbacks.onToolOutput) {
+    try {
+      callbacks.onToolOutput(name, output, error);
+    } catch { /* ignore callback errors */ }
+  }
+
+  return { id, name, output, error };
+}
+
+// ─── offloadToolResult ────────────────────────────────────────────────────────
+
+/**
+ * Write long tool results to disk, return a preview + file path.
+ * Directory: ~/.junecode/tool-results/
+ */
+function offloadToolResult(toolName, fullResult) {
+  const dir = join(homedir(), '.junecode', 'tool-results');
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  const ts = Date.now();
+  const rand = Math.random().toString(36).slice(2, 8);
+  const filename = `${ts}-${rand}-${toolName}.txt`;
+  const filepath = join(dir, filename);
+
+  writeFileSync(filepath, fullResult, 'utf-8');
+
+  const preview = fullResult.slice(0, TOOL_RESULT_PREVIEW);
+  return `${preview}\n\n[Result offloaded: ${fullResult.length} chars. Full output at ${filepath}]`;
+}

package/mcp.mjs

@@ -0,0 +1,209 @@
+/**
+ * MCP (Model Context Protocol) management.
+ *
+ * Communicates with MCP servers via JSON-RPC over stdio.
+ * Each connected server's tools are added to the agent with an mcp_ prefix.
+ * Child processes are tracked on agent._mcpProcesses for cleanup.
+ */
+
+import { spawn } from 'node:child_process';
+
+// ─── JSON-RPC helpers ──────────────────────────────────────────────────────────
+
+let _nextId = 1;
+
+/** Send a JSON-RPC request and wait for the response. */
+function jsonRpc(proc, method, params = null) {
+  return new Promise((resolve, reject) => {
+    const id = _nextId++;
+    const request = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+
+    const onData = (chunk) => {
+      buffer += chunk.toString();
+      // Process complete lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop(); // keep incomplete line in buffer
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id === id) {
+            proc.stdout.removeListener('data', onData);
+            clearTimeout(timer);
+            if (msg.error) reject(new Error(`MCP error: ${msg.error.message || JSON.stringify(msg.error)}`));
+            else resolve(msg.result);
+          }
+        } catch { /* skip parse errors */ }
+      }
+    };
+
+    let buffer = '';
+    proc.stdout.on('data', onData);
+
+    const timer = setTimeout(() => {
+      proc.stdout.removeListener('data', onData);
+      reject(new Error(`MCP request timed out (method: ${method})`));
+    }, 15000);
+
+    proc.stdin.write(request);
+  });
+}
+
+/** Send a JSON-RPC notification (no response expected). */
+function jsonRpcNotify(proc, method, params = null) {
+  const msg = JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n';
+  proc.stdin.write(msg);
+}
+
+// ─── Tool conversion ───────────────────────────────────────────────────────────
+
+/**
+ * Convert an MCP tool definition to an internal tool with an execute wrapper.
+ * MCP tools send tools/call requests to the child process.
+ */
+function mcpToolToInternal(mcpTool, proc, serverName) {
+  const name = `mcp_${serverName}_${mcpTool.name}`;
+
+  // MCP tool inputSchema → OpenAI parameters
+  const parameters = mcpTool.inputSchema || { type: 'object', properties: {} };
+
+  return {
+    name,
+    description: mcpTool.description || `MCP tool: ${mcpTool.name}`,
+    parameters,
+    readonly: false,
+    parallel: true,
+
+    async execute(args, agent) {
+      try {
+        const result = await jsonRpc(proc, 'tools/call', {
+          name: mcpTool.name,
+          arguments: args,
+        });
+
+        // MCP result is an array of content items
+        if (result.content && Array.isArray(result.content)) {
+          return result.content
+            .map((c) => (c.type === 'text' ? c.text : JSON.stringify(c)))
+            .join('\n');
+        }
+        if (result.isError) {
+          return `MCP tool error: ${JSON.stringify(result)}`;
+        }
+        return JSON.stringify(result);
+      } catch (err) {
+        return `MCP tool "${mcpTool.name}" failed: ${err.message}`;
+      }
+    },
+  };
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Connect to an MCP server. Returns list of internal tool definitions.
+ *
+ * @param {object} srv - Server config: { name, command, args?: string[], env?: object }
+ * @returns {Promise<object[]>} array of tool definitions
+ */
+export async function connectMcpServer(srv) {
+  if (!srv || !srv.command) return [];
+
+  const name = srv.name || 'mcp';
+  const command = srv.command;
+  const args = srv.args || [];
+  const env = { ...process.env, ...(srv.env || {}) };
+
+  let proc;
+  try {
+    proc = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env,
+      shell: false,
+    });
+  } catch (err) {
+    throw new Error(`Failed to spawn MCP server "${name}": ${err.message}`);
+  }
+
+  // Collect stderr for debugging
+  let stderr = '';
+  proc.stderr.on('data', (chunk) => {
+    stderr += chunk.toString();
+  });
+  proc.on('error', () => { /* handled via exit */ });
+
+  try {
+    // Step 1: Initialize
+    const initResult = await jsonRpc(proc, 'initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: { tools: {} },
+      clientInfo: { name: 'junecode', version: '1.0.0' },
+    });
+
+    // Step 2: Send initialized notification
+    jsonRpcNotify(proc, 'notifications/initialized');
+
+    // Step 3: List tools
+    const listResult = await jsonRpc(proc, 'tools/list');
+    const mcpTools = listResult.tools || [];
+
+    // Convert to internal tools
+    const tools = mcpTools.map((t) => mcpToolToInternal(t, proc, name));
+
+    // Attach process reference so we can close it later
+    tools._mcpProc = proc;
+    tools._mcpName = name;
+
+    return tools;
+  } catch (err) {
+    // Clean up on failure
+    try { proc.kill(); } catch { /* ignore */ }
+    throw new Error(`MCP server "${name}" connection failed: ${err.message}${stderr ? '\nStderr: ' + stderr.slice(-500) : ''}`);
+  }
+}
+
+/**
+ * Close all active MCP connections for an agent.
+ * Kills all tracked child processes.
+ * @param {object} agent
+ */
+export async function closeAllMcp(agent) {
+  if (!agent || !agent._mcpProcesses) return;
+
+  for (const proc of agent._mcpProcesses) {
+    try { proc.kill('SIGTERM'); } catch { /* already dead */ }
+  }
+  agent._mcpProcesses = [];
+}
+
+/**
+ * Remove MCP tools associated with a named server from an agent's tool set.
+ * @param {object} agent
+ * @param {string} name - server name
+ */
+export function removeMcpTools(agent, name) {
+  if (!agent || !agent.tools) return;
+
+  const prefix = `mcp_${name}_`;
+
+  // Filter out tools with matching prefix
+  agent.tools = agent.tools.filter((t) => {
+    if (t.name?.startsWith(prefix)) {
+      // Also remove from toolByName map if it exists
+      if (agent._toolByName) agent._toolByName.delete(t.name);
+      return false;
+    }
+    return true;
+  });
+
+  // Kill the process if tracked
+  if (agent._mcpProcesses) {
+    agent._mcpProcesses = agent._mcpProcesses.filter((p) => {
+      if (p._mcpName === name) {
+        try { p.kill('SIGTERM'); } catch { /* ignore */ }
+        return false;
+      }
+      return true;
+    });
+  }
+}

package/memory.mjs

@@ -0,0 +1,218 @@
+/**
+ * Memory module — search and reindex for the agent's long-term memory.
+ *
+ * Memory is a simple keyword-search store backed by JSON files on disk.
+ * The `memory` object shape: { dir: string, entries?: MemoryEntry[] }.
+ *
+ * Each memory entry: { id, content, source, tags, timestamp }.
+ */
+
+import { join, basename } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+
+// ─── Helpers ───────────────────────────────────────────────────────────────────
+
+/** Default memory directory */
+export function memoryDir() {
+  return join(homedir(), '.junecode', 'memory');
+}
+
+/** Load all memory entries from disk. */
+function loadEntries(dir) {
+  if (!existsSync(dir)) return [];
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const f of files) {
+    if (!f.endsWith('.json')) continue;
+    try {
+      const raw = readFileSync(join(dir, f), 'utf-8');
+      entries.push(JSON.parse(raw));
+    } catch {
+      // skip corrupt files
+    }
+  }
+  return entries;
+}
+
+/** Save a single entry to disk. */
+function saveEntry(dir, entry) {
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch { /* dir exists */ }
+  writeFileSync(join(dir, entry.id + '.json'), JSON.stringify(entry, null, 2), 'utf-8');
+}
+
+/** Generate a content-based ID. */
+function hashId(content) {
+  return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+
+/** Simple tokenizer: lowercase, split on non-word chars, filter short tokens. */
+function tokenize(text) {
+  return text
+    .toLowerCase()
+    .split(/[^a-z0-9\u4e00-\u9fff]+/i)
+    .filter((t) => t.length > 1);
+}
+
+/** Score a memory entry against query tokens. */
+function scoreEntry(entry, queryTokens) {
+  const contentTokens = tokenize(entry.content);
+  const tagTokens = tokenize((entry.tags || '').join(' '));
+  const allTokens = [...contentTokens, ...tagTokens];
+
+  let score = 0;
+  const seen = new Set();
+  for (const qt of queryTokens) {
+    if (seen.has(qt)) continue;
+    seen.add(qt);
+    for (const t of allTokens) {
+      if (t === qt) {
+        score += 1;
+      } else if (t.includes(qt) || qt.includes(t)) {
+        score += 0.5;
+      }
+    }
+  }
+  return score;
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Search the agent's memory.
+ * @param {object} memory - memory instance with { dir, entries? }
+ * @param {string} input - query string
+ * @param {{ limit?: number }} [opts]
+ * @returns {Promise<string>} formatted search results
+ */
+export async function search(memory, input, opts = {}) {
+  if (!memory) return '';
+
+  const dir = memory.dir || memoryDir();
+  const limit = opts.limit || 5;
+  const queryTokens = tokenize(input);
+  if (queryTokens.length === 0) return '';
+
+  // Load entries (from cache or disk)
+  let entries = memory.entries;
+  if (!entries) {
+    entries = loadEntries(dir);
+    memory.entries = entries;
+  }
+
+  if (entries.length === 0) return '';
+
+  // Score and rank
+  const scored = entries
+    .map((e) => ({ entry: e, score: scoreEntry(e, queryTokens) }))
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit);
+
+  if (scored.length === 0) return '';
+
+  return scored
+    .map((s) => {
+      const e = s.entry;
+      const preview = e.content.length > 200
+        ? e.content.slice(0, 200) + '...'
+        : e.content;
+      const tags = e.tags?.length ? ` [${e.tags.join(', ')}]` : '';
+      return `- ${preview}${tags} (source: ${e.source || 'unknown'})`;
+    })
+    .join('\n');
+}
+
+/**
+ * Re-index a file in the agent's memory.
+ * Reads the file content and stores it as a memory entry.
+ * @param {object} memory - memory instance
+ * @param {string} cwd - working directory
+ * @param {string} absPath - absolute path of the file that changed
+ */
+export async function reindexFile(memory, cwd, absPath) {
+  if (!memory) return;
+
+  const dir = memory.dir || memoryDir();
+
+  // Read the file
+  let content;
+  try {
+    content = readFileSync(absPath, 'utf-8');
+  } catch {
+    return; // can't read — skip
+  }
+
+  // Skip overly large files (avoid blowing up memory)
+  if (content.length > 50000) return;
+
+  const id = hashId(absPath + content.slice(0, 1000));
+  const fileName = basename(absPath);
+
+  const entry = {
+    id,
+    content: `File ${fileName}: ${content.slice(0, 2000)}`,
+    source: absPath,
+    tags: ['file', fileName],
+    timestamp: Date.now(),
+  };
+
+  // Update in-memory cache
+  let entries = memory.entries;
+  if (!entries) {
+    entries = loadEntries(dir);
+    memory.entries = entries;
+  }
+
+  // Replace existing entry with same source
+  const idx = entries.findIndex((e) => e.source === absPath);
+  if (idx >= 0) {
+    entries[idx] = entry;
+  } else {
+    entries.push(entry);
+  }
+
+  // Persist to disk
+  saveEntry(dir, entry);
+}
+
+/**
+ * Save a memory entry manually (called by memory_put tool).
+ * @param {object} memory - memory instance
+ * @param {object} entry - { type, title, content, tags, scope }
+ * @returns {Promise<string>} status message
+ */
+export async function put(memory, entry) {
+  if (!memory) return 'no memory store';
+
+  const dir = memory.dir || memoryDir();
+  const id = hashId(entry.content || entry.title || String(Date.now()));
+
+  const record = {
+    id,
+    content: `[${entry.type || 'knowledge'}] ${entry.title || ''}: ${entry.content}`,
+    source: entry.scope || 'manual',
+    tags: [...(entry.tags || []), entry.type || 'knowledge'],
+    timestamp: Date.now(),
+  };
+
+  // Update in-memory cache
+  let entries = memory.entries;
+  if (!entries) {
+    entries = loadEntries(dir);
+    memory.entries = entries;
+  }
+  entries.push(record);
+
+  saveEntry(dir, record);
+  return `saved: ${entry.title || id}`;
+}
+