@mrpatronz/nexusflow 0.2.7 → 0.2.8

package/src/mcp/server.ts

@@ -9,6 +9,7 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { loadConfig } from '../core/config.js';
 import { loadFeatureConfig } from '../core/workspace.js';
+import { callLocalLlm } from '../utils/local-ai.js';
 
 export async function startMcpServer(workspacePath?: string) {
   const server = new Server(
@@ -24,86 +25,73 @@ export async function startMcpServer(workspacePath?: string) {
   );
 
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-      tools: [
-        {
-          name: 'search_workspace',
-          description: 'Search for a string or regex across all repositories in the NexusFlow workspace. Extremely fast and useful for finding where a specific variable, function, or concept is used across microservices.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              query: {
-                type: 'string',
-                description: 'The search query or regular expression',
-              },
-              workspaceId: {
-                type: 'string',
-                description: 'Optional ID/branchName of the workspace to search. If omitted, uses the currently active workspace.',
-              },
+    const config = await loadConfig();
+    const tools: any[] = [
+      {
+        name: 'search_workspace',
+        description: 'Search for a string or regex across all repositories in the NexusFlow workspace. Extremely fast and useful for finding where a specific variable, function, or concept is used across microservices.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'The search query or regular expression',
             },
-            required: ['query'],
-          },
-        },
-        {
-          name: 'get_service_logs',
-          description: 'Get the recent logs for a specific running service in the workspace to debug runtime issues.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              serviceName: {
-                type: 'string',
-                description: 'The name of the service to fetch logs for (e.g. "frontend", "backend-api")',
-              },
-              lines: {
-                type: 'number',
-                description: 'Number of lines to fetch. Default 50.',
-              },
-              workspaceId: {
-                type: 'string',
-                description: 'Optional ID/branchName of the workspace. If omitted, uses the currently active workspace.',
-              },
+            workspaceId: {
+              type: 'string',
+              description: 'Optional ID/branchName of the workspace to search. If omitted, uses the currently active workspace.',
             },
-            required: ['serviceName'],
           },
+          required: ['query'],
         },
-        {
-          name: 'get_workspace_graph',
-          description: 'Retrieve the structural architecture graph of the NexusFlow workspace. Contains nodes for repos, packages, API endpoints, and exposed ports, plus relation edges (CONTAINS, DEPENDS_ON, EXPOSES, CALLS). Highly token-efficient for global workspace context.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              workspaceId: {
-                type: 'string',
-                description: 'Optional ID/branchName of the workspace. If omitted, uses the currently active workspace.',
-              },
+      },
+      {
+        name: 'get_service_logs',
+        description: 'Get the recent logs for a specific running service in the workspace to debug runtime issues.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            serviceName: {
+              type: 'string',
+              description: 'The name of the service to fetch logs for (e.g. "frontend", "backend-api")',
+            },
+            lines: {
+              type: 'number',
+              description: 'Number of lines to fetch. Default 50.',
+            },
+            workspaceId: {
+              type: 'string',
+              description: 'Optional ID/branchName of the workspace. If omitted, uses the currently active workspace.',
             },
           },
+          required: ['serviceName'],
         },
-        {
-          name: 'query_workspace_graph',
-          description: 'Query the workspace architecture graph by filtering nodes or edges (e.g., node types like "repo", "package", "endpoint", "port", or edge types like "DEPENDS_ON", "EXPOSES", "CALLS"). Reduces token payload by fetching specific architectural paths.',
-          inputSchema: {
-            type: 'object',
-            properties: {
-              nodeType: {
-                type: 'string',
-                enum: ['repo', 'package', 'endpoint', 'port'],
-                description: 'Optional node type to filter.',
-              },
-              edgeType: {
-                type: 'string',
-                enum: ['DEPENDS_ON', 'EXPOSES', 'CALLS'],
-                description: 'Optional edge/relation type to filter.',
-              },
-              workspaceId: {
-                type: 'string',
-                description: 'Optional ID/branchName of the workspace. If omitted, uses the currently active workspace.',
-              },
+      },
+    ];
+
+    if (config.localLlm?.enabled) {
+      tools.push({
+        name: 'delegate_to_local_agent',
+        description: 'Delegate simple, high-volume, or repetitive tasks (like searching code, parsing raw service logs, or generating boilerplate) to the local Small Language Model (SLM) running on the user\'s machine to save remote tokens.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            instruction: {
+              type: 'string',
+              description: 'The specific instruction for the local agent (e.g., "Scan the last 50 lines of logs and explain the database error").',
+            },
+            filesToRead: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Optional list of workspace-relative file paths or log files that the local agent should read and use as context.',
             },
           },
+          required: ['instruction'],
         },
-      ],
-    };
+      });
+    }
+
+    return { tools };
   });
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
@@ -121,6 +109,90 @@ export async function startMcpServer(workspacePath?: string) {
       }
     }
 
+    if (name === 'delegate_to_local_agent') {
+      const instruction = (args as any).instruction;
+      const filesToRead = (args as any).filesToRead || [];
+
+      try {
+        if (!config.localLlm || !config.localLlm.enabled) {
+          throw new Error('Local AI agent delegation is disabled. Enable it in ~/.nexusflow/config.json or settings.');
+        }
+
+        const contextFiles: { path: string; content: string }[] = [];
+        const normalizedWorkspace = resolvedWorkspacePath.endsWith(path.sep)
+          ? resolvedWorkspacePath
+          : resolvedWorkspacePath + path.sep;
+
+        for (const relativePath of filesToRead) {
+          const filePath = path.resolve(resolvedWorkspacePath, relativePath);
+          
+          if (!filePath.startsWith(normalizedWorkspace)) {
+            contextFiles.push({
+              path: relativePath,
+              content: '[Access denied: path is outside workspace boundary]',
+            });
+            continue;
+          }
+
+          try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            // Truncate file content if it's too large to prevent overloading local SLM
+            const truncatedContent = content.length > 50000
+              ? content.substring(0, 50000) + '\n\n[Content truncated by NexusFlow to save local context size...]'
+              : content;
+
+            contextFiles.push({
+              path: relativePath,
+              content: truncatedContent,
+            });
+          } catch (e: any) {
+            contextFiles.push({
+              path: relativePath,
+              content: `[Error reading file: ${e.message || 'unknown error'}]`,
+            });
+          }
+        }
+
+        // Build messages
+        const messages: import('../utils/local-ai.js').LocalLlmMessage[] = [];
+        let systemPrompt = 'You are the NexusFlow local assistant. You are running locally on the user\'s machine to help the remote supervisor agent solve a specific sub-task in a multi-repo workspace.\n';
+        systemPrompt += 'Your goal is to be extremely precise, concise, and return only the distilled findings/code to save remote network tokens. Keep your response short, focused, and directly address the instruction.';
+
+        messages.push({ role: 'system', content: systemPrompt });
+
+        let userPrompt = '';
+        if (contextFiles.length > 0) {
+          userPrompt += 'Here is the local file/log context:\n\n';
+          for (const file of contextFiles) {
+            userPrompt += `--- FILE: ${file.path} ---\n${file.content}\n\n`;
+          }
+        }
+        userPrompt += `Instruction: ${instruction}`;
+        messages.push({ role: 'user', content: userPrompt });
+
+        const result = await callLocalLlm(config.localLlm, messages);
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: result,
+            },
+          ],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error delegating to local agent: ${error.message}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+
     if (name === 'search_workspace') {
       const query = (args as any).query;
       try {
@@ -142,9 +214,7 @@ export async function startMcpServer(workspacePath?: string) {
               allResults += lines.join('\n') + '\n';
             }
           } catch (e: any) {
-            if (e.exitCode !== 1) {
-              console.error(`Error searching in ${repoName}:`, e);
-            }
+            // Ignore error or exitCode 1 (no match)
           }
         }
 
@@ -215,28 +285,7 @@ export async function startMcpServer(workspacePath?: string) {
       }
     }
 
-    if (name === 'get_workspace_graph') {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: 'This tool has been deprecated. Use nexusflow-plan.md for dependency information.',
-          },
-        ],
-      };
-    }
-
-    if (name === 'query_workspace_graph') {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: 'This tool has been deprecated. Use nexusflow-plan.md for dependency information.',
-          },
-        ],
-      };
-    }
-
+    // Unknown tool
     throw new Error(`Tool not found: ${name}`);
   });
 

package/src/server.test.ts

@@ -0,0 +1,367 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import { execa } from 'execa';
+import { app } from './server.js';
+import * as workspace from './core/workspace.js';
+import * as config from './core/config.js';
+import * as systemScanner from './utils/system-scanner.js';
+import * as localAi from './utils/local-ai.js';
+import * as updateCheck from './utils/update-check.js';
+
+// Mock dependencies
+vi.mock('node:fs/promises');
+vi.mock('execa');
+vi.mock('./core/workspace.js');
+vi.mock('./core/config.js');
+vi.mock('./utils/system-scanner.js');
+vi.mock('./utils/local-ai.js');
+vi.mock('./utils/update-check.js');
+
+describe('Server API Endpoints Unit Tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('POST /api/open-editor', () => {
+    it('should return 400 for forbidden editor commands', async () => {
+      const response = await app.request('/api/open-editor', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          workspacePath: '/mock/workspace/path',
+          command: 'rm -rf /'
+        })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json();
+      expect(data.error).toBe('Forbidden editor command');
+    });
+
+    it('should return 400 if workspace path does not exist', async () => {
+      vi.spyOn(fs, 'stat').mockRejectedValue(new Error('File not found'));
+
+      const response = await app.request('/api/open-editor', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          workspacePath: '/non-existent/path',
+          command: 'code-insiders'
+        })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json();
+      expect(data.error).toBe('Workspace path does not exist');
+    });
+
+    it('should return 400 if workspace path is not a directory', async () => {
+      vi.spyOn(fs, 'stat').mockResolvedValue({
+        isDirectory: () => false
+      } as any);
+
+      const response = await app.request('/api/open-editor', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          workspacePath: '/mock/file.txt',
+          command: 'code-insiders'
+        })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json();
+      expect(data.error).toBe('Workspace path is not a directory');
+    });
+
+    it('should call execa with detached, stdio, shell, and cleanup options and return success', async () => {
+      vi.spyOn(fs, 'stat').mockResolvedValue({
+        isDirectory: () => true
+      } as any);
+
+      // Mock execa to return a dummy child process with a catch method
+      const dummyChild = {
+        unref: vi.fn(),
+        catch: vi.fn().mockReturnThis()
+      };
+      vi.mocked(execa).mockReturnValue(dummyChild as any);
+
+      const response = await app.request('/api/open-editor', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          workspacePath: '/mock/workspace/dir',
+          command: 'code-insiders'
+        })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+
+      const isWin = process.platform === 'win32';
+      expect(execa).toHaveBeenCalledWith('code-insiders', ['/mock/workspace/dir'], {
+        detached: true,
+        stdio: 'ignore',
+        shell: isWin,
+        cleanup: false
+      });
+      expect(dummyChild.unref).toHaveBeenCalled();
+      expect(dummyChild.catch).toHaveBeenCalled();
+    });
+  });
+
+  describe('POST /api/workspace/:id/resume', () => {
+    it('should fail with 400 if command is forbidden', async () => {
+      vi.spyOn(config, 'loadConfig').mockResolvedValue({
+        workspacesDir: '/mock/workspaces'
+      } as any);
+      vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue({
+        id: 'test-ws',
+        repos: [],
+        assistants: ['antigravity']
+      } as any);
+
+      const response = await app.request('/api/workspace/test-ws/resume', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: 'malicious-editor',
+          assistant: 'antigravity'
+        })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json();
+      expect(data.error).toBe('Forbidden editor command');
+    });
+
+    it('should spawn the editor with proper options when resuming', async () => {
+      vi.spyOn(config, 'loadConfig').mockResolvedValue({
+        workspacesDir: '/mock/workspaces'
+      } as any);
+      vi.spyOn(workspace, 'loadFeatureConfig').mockResolvedValue({
+        id: 'test-ws',
+        repos: [],
+        assistants: ['antigravity']
+      } as any);
+
+      const dummyChild = {
+        unref: vi.fn(),
+        catch: vi.fn().mockReturnThis()
+      };
+      vi.mocked(execa).mockReturnValue(dummyChild as any);
+
+      const response = await app.request('/api/workspace/test-ws/resume', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          command: 'code',
+          assistant: 'antigravity'
+        })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+
+      const isWin = process.platform === 'win32';
+      expect(execa).toHaveBeenCalledWith('code', [expect.any(String)], {
+        detached: true,
+        stdio: 'ignore',
+        shell: isWin,
+        cleanup: false
+      });
+      expect(dummyChild.unref).toHaveBeenCalled();
+      expect(dummyChild.catch).toHaveBeenCalled();
+    });
+  });
+
+  describe('GET /api/config', () => {
+    it('should load configuration successfully', async () => {
+      vi.spyOn(config, 'getConfigDir').mockReturnValue('/mock/config-dir');
+      vi.spyOn(config, 'loadConfig').mockResolvedValue({
+        devDir: '/mock/dev',
+        scanDepth: 2
+      } as any);
+      vi.spyOn(fs, 'access').mockResolvedValue();
+
+      const response = await app.request('/api/config');
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.config.devDir).toBe('/mock/dev');
+      expect(data.exists).toBe(true);
+    });
+  });
+
+  describe('POST /api/config', () => {
+    it('should validate endpoint domain safety', async () => {
+      const response = await app.request('/api/config', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          localLlm: {
+            enabled: true,
+            endpoint: 'http://malicious-external-domain.com'
+          }
+        })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json();
+      expect(data.error).toContain('Local AI endpoint must be localhost, 127.0.0.1, or a private LAN IP.');
+    });
+
+    it('should save safe endpoint and config', async () => {
+      vi.spyOn(config, 'saveConfig').mockResolvedValue();
+
+      const response = await app.request('/api/config', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          localLlm: {
+            enabled: true,
+            endpoint: 'http://127.0.0.1:11434'
+          }
+        })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+    });
+  });
+
+  describe('POST /api/local-llm/test', () => {
+    it('should reject unsafe endpoints', async () => {
+      const response = await app.request('/api/local-llm/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          endpoint: 'http://unsafe-domain.com',
+          provider: 'ollama',
+          model: 'qwen2.5-coder:1.5b'
+        })
+      });
+
+      expect(response.status).toBe(400);
+      const data = await response.json();
+      expect(data.success).toBe(false);
+      expect(data.error).toContain('Local AI endpoint must be');
+    });
+
+    it('should perform inference shoot test if shoot = true', async () => {
+      vi.spyOn(localAi, 'callLocalLlm').mockResolvedValue('OK\n');
+
+      const response = await app.request('/api/local-llm/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          endpoint: 'http://localhost:11434',
+          provider: 'ollama',
+          model: 'qwen2.5-coder:1.5b',
+          shoot: true
+        })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+      expect(data.modelReady).toBe(true);
+      expect(data.message).toContain('Inference test succeeded');
+    });
+  });
+
+  describe('GET /api/local-llm/recommend', () => {
+    it('should fetch system specs and return them', async () => {
+      vi.spyOn(systemScanner, 'scanSystemSpecs').mockResolvedValue({
+        totalRamGb: 16,
+        gpuName: 'Nvidia RTX 4080',
+        hasHardwareAcceleration: true,
+        recommendedModel: 'qwen2.5-coder:7b'
+      });
+
+      const response = await app.request('/api/local-llm/recommend');
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.totalRamGb).toBe(16);
+      expect(data.gpuName).toBe('Nvidia RTX 4080');
+      expect(data.recommendedModel).toBe('qwen2.5-coder:7b');
+    });
+  });
+
+  describe('GET and PUT /api/workspace/:id/knowledge', () => {
+    it('should get workspace knowledge content', async () => {
+      vi.spyOn(config, 'loadConfig').mockResolvedValue({
+        workspacesDir: '/mock/workspaces'
+      } as any);
+      vi.spyOn(fs, 'readFile').mockResolvedValue('# Mock Knowledge File content');
+
+      const response = await app.request('/api/workspace/test-ws/knowledge');
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.content).toBe('# Mock Knowledge File content');
+    });
+
+    it('should write workspace knowledge content', async () => {
+      vi.spyOn(config, 'loadConfig').mockResolvedValue({
+        workspacesDir: '/mock/workspaces'
+      } as any);
+      vi.spyOn(fs, 'writeFile').mockResolvedValue();
+
+      const response = await app.request('/api/workspace/test-ws/knowledge', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ content: '# Updated Content' })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+    });
+  });
+
+  describe('GET /api/workspace/:id/plan', () => {
+    it('should get workspace plan content', async () => {
+      vi.spyOn(config, 'loadConfig').mockResolvedValue({
+        workspacesDir: '/mock/workspaces'
+      } as any);
+      vi.spyOn(fs, 'readFile').mockResolvedValue('# Mock Plan content');
+
+      const response = await app.request('/api/workspace/test-ws/plan');
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.content).toBe('# Mock Plan content');
+    });
+  });
+
+  describe('POST /api/updates/install', () => {
+    it('should fail if tool not found', async () => {
+      const response = await app.request('/api/updates/install', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ toolId: 'invalid-tool' })
+      });
+
+      expect(response.status).toBe(404);
+      const data = await response.json();
+      expect(data.error).toBe('Tool not found');
+    });
+
+    it('should install tool successfully if execa exits with 0', async () => {
+      vi.mocked(execa).mockResolvedValue({ exitCode: 0, stdout: 'Successfully updated' } as any);
+
+      const response = await app.request('/api/updates/install', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ toolId: 'repomix' })
+      });
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+      expect(data.success).toBe(true);
+      expect(data.output).toBe('Successfully updated');
+      expect(execa).toHaveBeenCalledWith('npm', ['install', '-g', 'repomix'], expect.any(Object));
+    });
+  });
+});