aegiscode 3.1.10 → 3.4.2

package/src/mcp/server.ts

@@ -1,334 +0,0 @@
-/**
- * AEGIS MCP Server — Exposes native tools (read, write, edit, glob, grep, bash,
- * memory_graph) via standard Model Context Protocol transport.
- *
- * Grok connects to this server as an MCP client and uses the tools as a
- * sub-agent for planning, debugging, and refactoring tasks.
- *
- * Usage:
- *   npx tsx src/mcp/server.ts              # stdio transport (default)
- *   npx tsx src/mcp/server.ts --port 3100  # SSE transport over HTTP
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { execSync, spawn } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as http from 'http';
-import * as readline from 'readline';
-
-// ── Optimized Tool Schemas ────────────────────────────────────────────────
-// Compact definitions for token efficiency — 78% fewer tokens vs verbose schemas.
-
-const TOOLS = [
-  {
-    name: 'read',
-    description: 'Read file contents. Returns full text.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string', description: 'Absolute path to file' },
-        offset: { type: 'number', description: 'Optional line offset (0-based)' },
-        limit: { type: 'number', description: 'Optional max lines' },
-      },
-      required: ['file_path'],
-    },
-  },
-  {
-    name: 'write',
-    description: 'Write file contents. Creates parent dirs automatically.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string', description: 'Absolute path' },
-        contents: { type: 'string', description: 'Full file content' },
-      },
-      required: ['file_path', 'contents'],
-    },
-  },
-  {
-    name: 'edit',
-    description: 'Edit file via exact string replacement.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string', description: 'Absolute path to file' },
-        old_string: { type: 'string', description: 'Text to replace (must be unique)' },
-        new_string: { type: 'string', description: 'Replacement text' },
-        replace_all: { type: 'boolean', description: 'Replace all occurrences' },
-      },
-      required: ['file_path', 'old_string', 'new_string'],
-    },
-  },
-  {
-    name: 'glob',
-    description: 'Find files matching a glob pattern. Recursive by default.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        pattern: { type: 'string', description: 'Glob pattern, e.g. "*.ts"' },
-        path: { type: 'string', description: 'Optional search root' },
-      },
-      required: ['pattern'],
-    },
-  },
-  {
-    name: 'grep',
-    description: 'Search file contents with regex. Returns matches with line numbers.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        pattern: { type: 'string', description: 'Regex pattern' },
-        path: { type: 'string', description: 'Optional search root' },
-        include: { type: 'string', description: 'Glob filter, e.g. "*.py"' },
-        case_sensitive: { type: 'boolean', description: 'Default true' },
-      },
-      required: ['pattern'],
-    },
-  },
-  {
-    name: 'bash',
-    description: 'Execute a shell command. For security, runs with limited env.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        command: { type: 'string', description: 'Shell command to run' },
-        timeout: { type: 'number', description: 'Timeout in ms, default 30000' },
-        description: { type: 'string', description: 'Brief description for logging' },
-      },
-      required: ['command'],
-    },
-  },
-  {
-    name: 'memory_graph',
-    description: 'Query AEGIS semantic memory. Returns relevant facts and state.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        query: { type: 'string', description: 'Free-text search query' },
-        scope: {
-          type: 'string',
-          enum: ['project', 'user', 'global'],
-          description: 'Search scope',
-        },
-        limit: { type: 'number', description: 'Max results, default 10' },
-      },
-      required: ['query'],
-    },
-  },
-];
-
-// ── Tool Handlers ─────────────────────────────────────────────────────────
-
-function handleRead(filePath: string, offset?: number, limit?: number): string {
-  if (!fs.existsSync(filePath)) return JSON.stringify({ error: `File not found: ${filePath}` });
-  const content = fs.readFileSync(filePath, 'utf-8');
-  const lines = content.split('\n');
-  const start = offset ?? 0;
-  const end = limit ? start + limit : lines.length;
-  return lines.slice(start, end).join('\n');
-}
-
-function handleWrite(filePath: string, contents: string): string {
-  fs.mkdirSync(path.dirname(path.resolve(filePath)), { recursive: true });
-  fs.writeFileSync(filePath, contents, 'utf-8');
-  return JSON.stringify({ success: true, bytes: Buffer.byteLength(contents, 'utf-8') });
-}
-
-function handleEdit(filePath: string, oldStr: string, newStr: string, replaceAll?: boolean): string {
-  if (!fs.existsSync(filePath)) return JSON.stringify({ error: `File not found: ${filePath}` });
-  let content = fs.readFileSync(filePath, 'utf-8');
-  if (replaceAll) {
-    content = content.split(oldStr).join(newStr);
-  } else {
-    const idx = content.indexOf(oldStr);
-    if (idx === -1) return JSON.stringify({ error: 'old_string not found' });
-    content = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length);
-  }
-  fs.writeFileSync(filePath, content, 'utf-8');
-  return JSON.stringify({ success: true });
-}
-
-function handleGlob(pattern: string, searchPath?: string): string {
-  const { globSync } = require('glob');
-  const root = searchPath || process.cwd();
-  const matches = globSync(pattern, { cwd: root, nodir: false });
-  return JSON.stringify({ matches: matches.slice(0, 200), total: matches.length });
-}
-
-function handleGrep(pattern: string, searchPath?: string, include?: string, caseSensitive?: boolean): string {
-  try {
-    const root = searchPath || '.';
-    const ignoreCase = caseSensitive === false ? '-i' : '';
-    const extFilter = include ? `--include="${include}"` : '';
-    const result = execSync(`grep -rn ${ignoreCase} ${extFilter} "${pattern}" ${root}`, {
-      encoding: 'utf-8',
-      timeout: 15000,
-      maxBuffer: 1024 * 1024,
-    });
-    const lines = result.trim().split('\n').filter(Boolean);
-    return JSON.stringify({ matches: lines.slice(0, 100), total: lines.length });
-  } catch {
-    return JSON.stringify({ matches: [], total: 0 });
-  }
-}
-
-function handleBash(command: string, timeout?: number, description?: string): string {
-  try {
-    const t = Math.min((timeout || 30000), 60000);
-    const result = execSync(command, {
-      encoding: 'utf-8',
-      timeout: t,
-      maxBuffer: 10 * 1024 * 1024,
-      env: { ...process.env, PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin' },
-    });
-    return JSON.stringify({
-      stdout: result.slice(0, 50000),
-      stderr: '',
-      returncode: 0,
-      description: description || '',
-    });
-  } catch (e: any) {
-    return JSON.stringify({
-      stdout: e.stdout?.slice(0, 50000) || '',
-      stderr: e.stderr?.slice(0, 10000) || e.message?.slice(0, 200) || 'exec error',
-      returncode: e.status ?? -1,
-    });
-  }
-}
-
-function handleMemoryGraph(query: string, scope?: string, limit?: number): string {
-  // Memory graph queries go through the AEGIS embedding service via HTTP.
-  // If the AEGIS API is available locally, query it. Otherwise return empty.
-  try {
-    const apiUrl = process.env.AEGIS_API_URL || 'http://localhost:5000';
-    const body = JSON.stringify({ query, limit: limit || 10, scope: scope || 'project' });
-    const result = execSync(
-      `curl -s -X POST "${apiUrl}/api/memory/search" -H "Content-Type: application/json" --data-binary @-`,
-      { encoding: 'utf-8', timeout: 10000, input: body }
-    );
-    return result;
-  } catch {
-    // Memory not available — return empty
-    return JSON.stringify({ results: [], query, total: 0 });
-  }
-}
-
-// ── Create MCP Server ─────────────────────────────────────────────────────
-
-const server = new Server(
-  { name: 'aegis-native-tools', version: '1.0.0' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: TOOLS,
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  let result: string;
-
-  try {
-    switch (name) {
-      case 'read':
-        result = handleRead(args.file_path, args.offset, args.limit);
-        break;
-      case 'write':
-        result = handleWrite(args.file_path, args.contents);
-        break;
-      case 'edit':
-        result = handleEdit(args.file_path, args.old_string, args.new_string, args.replace_all);
-        break;
-      case 'glob':
-        result = handleGlob(args.pattern, args.path);
-        break;
-      case 'grep':
-        result = handleGrep(args.pattern, args.path, args.include, args.case_sensitive);
-        break;
-      case 'bash':
-        result = handleBash(args.command, args.timeout, args.description);
-        break;
-      case 'memory_graph':
-        result = handleMemoryGraph(args.query, args.scope, args.limit);
-        break;
-      default:
-        throw new Error(`Unknown tool: ${name}`);
-    }
-  } catch (e: any) {
-    return {
-      content: [{ type: 'text', text: JSON.stringify({ error: e.message || String(e) }) }],
-      isError: true,
-    };
-  }
-
-  return {
-    content: [{ type: 'text', text: result }],
-    isError: false,
-  };
-});
-
-// ── Startup ────────────────────────────────────────────────────────────────
-
-async function main() {
-  const args = process.argv.slice(2);
-  const portIndex = args.indexOf('--port');
-  const port = portIndex !== -1 ? parseInt(args[portIndex + 1], 10) : null;
-
-  if (port) {
-    // HTTP + SSE transport (for remote Grok connections)
-    const transports: SSEServerTransport[] = [];
-    const app = http.createServer(async (req, res) => {
-      const url = new URL(req.url || '/', `http://localhost:${port}`);
-
-      if (url.pathname === '/sse') {
-        const transport = new SSEServerTransport('/messages', res);
-        transports.push(transport);
-        await server.connect(transport);
-        return;
-      }
-
-      if (url.pathname === '/messages') {
-        const transport = transports.find(t => t.sessionId === url.searchParams.get('sessionId'));
-        if (transport) {
-          await transport.handlePostMessage(req, res);
-          return;
-        }
-        res.writeHead(404);
-        res.end('Not found');
-        return;
-      }
-
-      // Health check
-      if (url.pathname === '/health') {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ status: 'ok', tools: TOOLS.length }));
-        return;
-      }
-
-      res.writeHead(404);
-      res.end('Not found');
-    });
-
-    app.listen(port, () => {
-      process.stderr.write(`[AEGIS MCP Server] SSE transport on http://localhost:${port}/sse\n`);
-      process.stderr.write(`[AEGIS MCP Server] ${TOOLS.length} tools available\n`);
-    });
-  } else {
-    // stdio transport (default, for local Grok sub-process)
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    process.stderr.write('[AEGIS MCP Server] stdio transport — running\n');
-  }
-}
-
-main().catch((e) => {
-  process.stderr.write(`[AEGIS MCP Server] Fatal: ${e}\n`);
-  process.exit(1);
-});

package/src/mcp/test-server.ts

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-/**
- * 
- * 
- * 
- * 
- * 
- * - echo: 返回输入的文本
- * - time: 返回当前时间
- */
-
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-
-const server = new Server(
-  {
-    name: 'test-server',
-    version: '1.0.0',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
-
-// 列出工
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: 'echo',
-        description: 'Echo back the input text',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            text: {
-              type: 'string',
-              description: 'Text to echo',
-            },
-          },
-          required: ['text'],
-        },
-      },
-      {
-        name: 'time',
-        description: 'Get current time',
-        inputSchema: {
-          type: 'object',
-          properties: {},
-        },
-      },
-    ],
-  };
-});
-
-// 调用工
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-
-  if (name === 'echo') {
-    const text = (args as { text?: string })?.text || '';
-    return {
-      content: [{ type: 'text', text: `Echo: ${text}` }],
-    };
-  }
-
-  if (name === 'time') {
-    return {
-      content: [{ type: 'text', text: `Current time: ${new Date().toISOString()}` }],
-    };
-  }
-
-  throw new Error(`Unknown tool: ${name}`);
-});
-
-// 启动服务
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error('Test MCP server running on stdio');
-}
-
-main().catch(console.error);