nexus-mcp-agent 0.1.2

package/src/core/registry.ts

@@ -0,0 +1,72 @@
+import { createContextLogger } from './logger.js';
+
+const log = createContextLogger('registry');
+
+export interface ToolMetadata {
+  name: string;
+  category: string;
+  description: string;
+  parameters?: any;
+  handler: (params: any) => Promise<any>;
+  requiresConfirmation?: boolean;
+  sideEffects?: boolean;
+}
+
+export class ToolRegistry {
+  private tools: Map<string, ToolMetadata> = new Map();
+
+  register(tool: ToolMetadata): void {
+    if (this.tools.has(tool.name)) {
+      log.warn(`Tool ${tool.name} already registered, overwriting`);
+    }
+    this.tools.set(tool.name, tool);
+    log.debug(`Registered tool: ${tool.name} (${tool.category})`);
+  }
+
+  get(name: string): ToolMetadata | undefined {
+    return this.tools.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  list(): ToolMetadata[] {
+    return Array.from(this.tools.values());
+  }
+
+  listByCategory(category: string): ToolMetadata[] {
+    return this.list().filter(t => t.category === category);
+  }
+
+  getCategories(): string[] {
+    const categories = new Set<string>();
+    this.tools.forEach(t => categories.add(t.category));
+    return Array.from(categories);
+  }
+
+  getToolCount(): number {
+    return this.tools.size;
+  }
+
+  async execute(name: string, params: any): Promise<any> {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+
+    log.info({ params }, `Executing tool: ${name}`);
+    const startTime = Date.now();
+
+    try {
+      const result = await tool.handler(params);
+      const duration = Date.now() - startTime;
+      log.info({ duration }, `Tool ${name} completed`);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      log.error({ error, duration }, `Tool ${name} failed`);
+      throw error;
+    }
+  }
+}

package/src/core/server.ts

@@ -0,0 +1,144 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createContextLogger } from './logger.js';
+import { nexusConfig, validateConfig } from './config.js';
+import { ToolRegistry } from './registry.js';
+
+// Import tool modules
+import { registerWebTools } from '../tools/web/index.js';
+import { registerFilesystemTools } from '../tools/filesystem/index.js';
+import { registerTerminalTools } from '../tools/terminal/index.js';
+import { registerGitTools } from '../tools/git/index.js';
+import { registerMemoryTools } from '../tools/memory/index.js';
+import { registerAutomationTools } from '../tools/automation/index.js';
+import { registerAgentTools } from '../tools/agents/index.js';
+import { registerSystemTools } from '../tools/system/index.js';
+
+const log = createContextLogger('server');
+
+export class NexusServer {
+  private server: McpServer;
+  private registry: ToolRegistry;
+  private transport: StdioServerTransport | null = null;
+
+  constructor() {
+    this.server = new McpServer({
+      name: 'NEXUS',
+      version: '0.1.0',
+      description: 'Autonomous AI Agent Ecosystem - Self-empowered MCP Server',
+    });
+
+    this.registry = new ToolRegistry();
+  }
+
+  async initialize(): Promise<void> {
+    log.info('Initializing NEXUS server...');
+
+    // Validate configuration
+    const warnings = validateConfig();
+    warnings.forEach(w => log.warn(w));
+
+    // Register all tool categories
+    log.info('Registering tools...');
+    registerWebTools(this.server, this.registry);
+    registerFilesystemTools(this.server, this.registry);
+    registerTerminalTools(this.server, this.registry);
+    registerGitTools(this.server, this.registry);
+    registerMemoryTools(this.server, this.registry);
+    registerAutomationTools(this.server, this.registry);
+    registerAgentTools(this.server, this.registry);
+    registerSystemTools(this.server, this.registry);
+
+    const toolCount = this.registry.getToolCount();
+    log.info(`Registered ${toolCount} tools`);
+
+    // Register resources
+    this.registerResources();
+
+    // Register prompts
+    this.registerPrompts();
+  }
+
+  private registerResources(): void {
+    // System info resource
+    this.server.resource(
+      'system-info',
+      'nexus://system/info',
+      async (uri) => ({
+        contents: [{
+          uri: uri.href,
+          text: JSON.stringify({
+            name: 'NEXUS',
+            version: '0.1.0',
+            uptime: process.uptime(),
+            memory: process.memoryUsage(),
+            config: {
+              llmProvider: nexusConfig.llm.provider,
+              llmModel: nexusConfig.llm.model,
+              searchProvider: nexusConfig.search.provider,
+              vectorDb: nexusConfig.vector.type,
+              toolCount: this.registry.getToolCount(),
+            },
+          }, null, 2),
+        }],
+      })
+    );
+
+    log.info('Registered resources');
+  }
+
+  private registerPrompts(): void {
+    // System prompt for autonomous agent
+    this.server.prompt(
+      'autonomous-agent',
+      'System prompt for autonomous operation',
+      () => ({
+        messages: [{
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `You are NEXUS, an autonomous AI agent with full system access.
+
+You have the following capabilities:
+- Web research (search, browse, scrape)
+- File system operations (read, write, search)
+- Terminal access (execute commands, spawn processes)
+- Git operations
+- Persistent memory (store and recall information)
+- Task scheduling (cron jobs, workflows)
+- Multi-agent orchestration
+
+Guidelines:
+1. Always verify your actions before executing
+2. Log all significant operations
+3. Store important discoveries in memory
+4. Use sub-agents for complex parallel tasks
+5. Respect security boundaries
+6. Ask for confirmation on destructive operations
+
+Current workspace: ${nexusConfig.paths.workspace}
+Allowed directories: ${nexusConfig.security.allowedDirs.join(', ')}`,
+          },
+        }],
+      })
+    );
+
+    log.info('Registered prompts');
+  }
+
+  async start(): Promise<void> {
+    log.info('Starting MCP server on stdio...');
+    this.transport = new StdioServerTransport();
+    await this.server.connect(this.transport);
+    log.info('NEXUS server is running');
+  }
+
+  async stop(): Promise<void> {
+    log.info('Stopping NEXUS server...');
+    if (this.transport) {
+      await this.transport.close();
+    }
+    await this.server.close();
+    log.info('NEXUS server stopped');
+  }
+}

package/src/index.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import { NexusServer } from './core/server.js';
+import { createContextLogger } from './core/logger.js';
+
+const log = createContextLogger('main');
+
+async function main() {
+  log.info('🧠 NEXUS - Autonomous AI Agent Ecosystem');
+  log.info('========================================');
+
+  const server = new NexusServer();
+
+  // Handle graceful shutdown
+  process.on('SIGINT', async () => {
+    log.info('Received SIGINT, shutting down...');
+    await server.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGTERM', async () => {
+    log.info('Received SIGTERM, shutting down...');
+    await server.stop();
+    process.exit(0);
+  });
+
+  process.on('uncaughtException', (error) => {
+    log.fatal({ error }, 'Uncaught exception');
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason) => {
+    log.fatal({ reason }, 'Unhandled rejection');
+    process.exit(1);
+  });
+
+  try {
+    await server.initialize();
+    await server.start();
+  } catch (error) {
+    log.fatal({ error }, 'Failed to start NEXUS server');
+    process.exit(1);
+  }
+}
+
+main();

package/src/tools/agents/index.ts

@@ -0,0 +1,172 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import { v4 as uuid } from 'uuid';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger } from '../../core/logger.js';
+
+const log = createContextLogger('tools/agents');
+
+export interface Agent {
+  id: string;
+  name: string;
+  role: string;
+  systemPrompt: string;
+  skills: string[];
+  tools: string[];
+  status: 'idle' | 'running' | 'completed' | 'error';
+  createdAt: number;
+  lastActive?: number;
+}
+
+const agentTemplates: Record<string, Partial<Agent>> = {
+  researcher: {
+    name: 'Researcher',
+    role: 'Web research and information gathering',
+    systemPrompt: 'You are an expert researcher. Search the web thoroughly, verify information from multiple sources, and synthesize comprehensive answers.',
+    skills: ['web-research', 'fact-checking', 'synthesis'],
+    tools: ['web_search', 'web_browse', 'web_scrape', 'memory_store'],
+  },
+  coder: {
+    name: 'Coder',
+    role: 'Code generation and implementation',
+    systemPrompt: 'You are a senior fullstack developer. Write clean, well-tested code following best practices. Explain your decisions.',
+    skills: ['coding', 'testing', 'debugging'],
+    tools: ['fs_read', 'fs_write', 'shell_exec', 'git_commit'],
+  },
+  reviewer: {
+    name: 'Reviewer',
+    role: 'Code review and quality assurance',
+    systemPrompt: 'You are a code review expert. Identify bugs, security issues, performance problems, and style issues. Be constructive.',
+    skills: ['code-review', 'security-audit', 'best-practices'],
+    tools: ['fs_read', 'git_diff', 'git_log'],
+  },
+  sysadmin: {
+    name: 'Sysadmin',
+    role: 'System administration and DevOps',
+    systemPrompt: 'You are a system administrator. Manage servers, deployments, and infrastructure. Be careful with destructive operations.',
+    skills: ['server-management', 'deployment', 'monitoring'],
+    tools: ['shell_exec', 'fs_read', 'fs_write', 'process_list'],
+  },
+  analyst: {
+    name: 'Analyst',
+    role: 'Data analysis and insights',
+    systemPrompt: 'You are a data analyst. Analyze data, identify patterns, and provide actionable insights. Use Python/pandas when needed.',
+    skills: ['data-analysis', 'visualization', 'statistics'],
+    tools: ['shell_exec', 'fs_read', 'fs_write', 'memory_store'],
+  },
+};
+
+const agents: Map<string, Agent> = new Map();
+
+const AgentCreateSchema = z.object({
+  type: z.enum(['researcher', 'coder', 'reviewer', 'sysadmin', 'analyst']).optional(),
+  name: z.string().optional(),
+  role: z.string().optional(),
+  systemPrompt: z.string().optional(),
+});
+
+const AgentGetSchema = z.object({
+  id: z.string(),
+});
+
+const AgentDeleteSchema = z.object({
+  id: z.string(),
+});
+
+type AgentCreateParams = z.infer<typeof AgentCreateSchema>;
+type AgentGetParams = z.infer<typeof AgentGetSchema>;
+type AgentDeleteParams = z.infer<typeof AgentDeleteSchema>;
+
+async function agentCreate(params: AgentCreateParams): Promise<any> {
+  const { type, name, role, systemPrompt } = params;
+
+  const id = uuid();
+  const template = type ? agentTemplates[type] : {};
+
+  const agent: Agent = {
+    id,
+    name: name || template.name || 'Custom Agent',
+    role: role || template.role || 'General purpose',
+    systemPrompt: systemPrompt || template.systemPrompt || 'You are a helpful assistant.',
+    skills: template.skills || [],
+    tools: template.tools || [],
+    status: 'idle',
+    createdAt: Date.now(),
+  };
+
+  agents.set(id, agent);
+  log.info(`Created agent: ${agent.name} (${id})`);
+
+  return { success: true, agent };
+}
+
+async function agentList(): Promise<any> {
+  const agentList = Array.from(agents.values());
+  return { success: true, count: agentList.length, agents: agentList };
+}
+
+async function agentGet(params: AgentGetParams): Promise<any> {
+  const agent = agents.get(params.id);
+  if (!agent) return { success: false, error: 'Agent not found' };
+  return { success: true, agent };
+}
+
+async function agentDelete(params: AgentDeleteParams): Promise<any> {
+  if (!agents.has(params.id)) return { success: false, error: 'Agent not found' };
+  agents.delete(params.id);
+  return { success: true };
+}
+
+async function agentTemplates_(): Promise<any> {
+  return {
+    success: true,
+    templates: Object.entries(agentTemplates).map(([key, t]) => ({
+      type: key,
+      name: t.name,
+      role: t.role,
+      skills: t.skills,
+      tools: t.tools,
+    })),
+  };
+}
+
+export function registerAgentTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('agent_create', {
+    description: 'Create a new agent',
+    inputSchema: AgentCreateSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await agentCreate(params), null, 2) }],
+  }));
+
+  server.tool('agent_list', 'List all agents', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await agentList(), null, 2) }],
+  }));
+
+  server.registerTool('agent_get', {
+    description: 'Get agent details',
+    inputSchema: AgentGetSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await agentGet(params), null, 2) }],
+  }));
+
+  server.registerTool('agent_delete', {
+    description: 'Delete an agent',
+    inputSchema: AgentDeleteSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await agentDelete(params), null, 2) }],
+  }));
+
+  server.tool('agent_templates', 'List available agent templates', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await agentTemplates_(), null, 2) }],
+  }));
+
+  registry.register({ name: 'agent_create', category: 'agents', description: 'Create agent', handler: agentCreate });
+  registry.register({ name: 'agent_list', category: 'agents', description: 'List agents', handler: agentList });
+  registry.register({ name: 'agent_get', category: 'agents', description: 'Get agent', handler: agentGet });
+  registry.register({ name: 'agent_delete', category: 'agents', description: 'Delete agent', handler: agentDelete });
+  registry.register({ name: 'agent_templates', category: 'agents', description: 'Agent templates', handler: agentTemplates_ });
+
+  log.info('Registered 5 agent tools');
+}
+
+export { agents, agentTemplates };

package/src/tools/automation/index.ts

@@ -0,0 +1,127 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import cron from 'node-cron';
+import { v4 as uuid } from 'uuid';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger } from '../../core/logger.js';
+
+const log = createContextLogger('tools/automation');
+
+interface CronJob {
+  id: string;
+  schedule: string;
+  task: string;
+  enabled: boolean;
+  createdAt: number;
+  lastRun?: number;
+  taskFn: any;
+}
+
+const cronJobs: Map<string, CronJob> = new Map();
+
+const CronAddSchema = z.object({
+  schedule: z.string().describe('Cron expression (e.g. "*/5 * * * *")'),
+  task: z.string().describe('Description of the task'),
+});
+
+const CronRemoveSchema = z.object({
+  id: z.string(),
+});
+
+const CronToggleSchema = z.object({
+  id: z.string(),
+  enabled: z.boolean(),
+});
+
+type CronAddParams = z.infer<typeof CronAddSchema>;
+type CronRemoveParams = z.infer<typeof CronRemoveSchema>;
+type CronToggleParams = z.infer<typeof CronToggleSchema>;
+
+async function cronAdd(params: CronAddParams): Promise<any> {
+  const { schedule, task } = params;
+
+  if (!cron.validate(schedule)) {
+    return { success: false, error: 'Invalid cron schedule' };
+  }
+
+  const id = uuid();
+  log.info(`Adding cron job: ${id} (${schedule})`);
+
+  const job = {
+    id,
+    schedule,
+    task,
+    enabled: true,
+    createdAt: Date.now(),
+    taskFn: cron.schedule(schedule, () => {
+      log.info(`Cron job triggered: ${id} - ${task}`);
+      const jobData = cronJobs.get(id);
+      if (jobData) jobData.lastRun = Date.now();
+    }),
+  };
+
+  cronJobs.set(id, job);
+  return { success: true, id, schedule, task };
+}
+
+async function cronList(): Promise<any> {
+  const jobs = Array.from(cronJobs.values()).map(({ id, schedule, task, enabled, createdAt, lastRun }) => ({
+    id, schedule, task, enabled, createdAt, lastRun,
+  }));
+  return { success: true, count: jobs.length, jobs };
+}
+
+async function cronRemove(params: CronRemoveParams): Promise<any> {
+  const job = cronJobs.get(params.id);
+  if (!job) return { success: false, error: 'Job not found' };
+
+  job.taskFn.stop();
+  cronJobs.delete(params.id);
+  log.info(`Removed cron job: ${params.id}`);
+  return { success: true };
+}
+
+async function cronToggle(params: CronToggleParams): Promise<any> {
+  const job = cronJobs.get(params.id);
+  if (!job) return { success: false, error: 'Job not found' };
+
+  job.enabled = params.enabled;
+  if (params.enabled) job.taskFn.start();
+  else job.taskFn.stop();
+
+  return { success: true, id: params.id, enabled: params.enabled };
+}
+
+export function registerAutomationTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('cron_add', {
+    description: 'Add a scheduled task',
+    inputSchema: CronAddSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await cronAdd(params), null, 2) }],
+  }));
+
+  server.tool('cron_list', 'List scheduled tasks', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await cronList(), null, 2) }],
+  }));
+
+  server.registerTool('cron_remove', {
+    description: 'Remove a scheduled task',
+    inputSchema: CronRemoveSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await cronRemove(params), null, 2) }],
+  }));
+
+  server.registerTool('cron_toggle', {
+    description: 'Enable/disable a task',
+    inputSchema: CronToggleSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await cronToggle(params), null, 2) }],
+  }));
+
+  registry.register({ name: 'cron_add', category: 'automation', description: 'Add cron job', handler: cronAdd });
+  registry.register({ name: 'cron_list', category: 'automation', description: 'List cron jobs', handler: cronList });
+  registry.register({ name: 'cron_remove', category: 'automation', description: 'Remove cron job', handler: cronRemove });
+  registry.register({ name: 'cron_toggle', category: 'automation', description: 'Toggle cron job', handler: cronToggle });
+
+  log.info('Registered 4 automation tools');
+}