@mrpatronz/nexusflow 0.2.18 → 1.3.0

package/src/mcp/server.ts

@@ -1,294 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import { execa } from 'execa';
-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(
-    {
-      name: 'nexusflow-mcp',
-      version: '0.1.2',
-    },
-    {
-      capabilities: {
-        tools: {},
-      },
-    }
-  );
-
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    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',
-            },
-            workspaceId: {
-              type: 'string',
-              description: 'Optional ID/branchName of the workspace to search. If omitted, uses the currently active workspace.',
-            },
-          },
-          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.',
-            },
-          },
-          required: ['serviceName'],
-        },
-      },
-    ];
-
-    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) => {
-    const { name, arguments: args } = request.params;
-    const config = await loadConfig();
-
-    // Resolve workspace path
-    let resolvedWorkspacePath = workspacePath;
-    if (!resolvedWorkspacePath) {
-      if (args && typeof args === 'object' && 'workspaceId' in args && typeof args.workspaceId === 'string') {
-        resolvedWorkspacePath = path.join(config.workspacesDir, args.workspaceId);
-      } else {
-        // Fallback to CWD
-        resolvedWorkspacePath = process.cwd();
-      }
-    }
-
-    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 {
-        const feature = await loadFeatureConfig(resolvedWorkspacePath);
-        if (!feature) {
-          throw new Error(`Workspace not found at ${resolvedWorkspacePath}. Make sure you are in a NexusFlow workspace or provide a valid workspaceId.`);
-        }
-
-        let allResults = '';
-        for (const repoPath of feature.repos) {
-          const repoName = path.basename(repoPath);
-          const worktreePath = path.join(resolvedWorkspacePath, repoName);
-          
-          try {
-            await fs.access(worktreePath);
-            const { stdout } = await execa('git', ['grep', '-n', '-I', query], { cwd: worktreePath, reject: false });
-            if (stdout) {
-              const lines = stdout.split('\n').map(line => `[${repoName}] ${line}`);
-              allResults += lines.join('\n') + '\n';
-            }
-          } catch (e: any) {
-            // Ignore error or exitCode 1 (no match)
-          }
-        }
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: allResults || 'No results found across the workspace repositories.',
-            },
-          ],
-        };
-      } catch (error: any) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Error searching workspace: ${error.message}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-    }
-
-    if (name === 'get_service_logs') {
-      const serviceName = (args as any).serviceName;
-      const lines = (args as any).lines || 50;
-
-      try {
-        const logFilePath = path.join(resolvedWorkspacePath, '.nexusflow-logs', `${serviceName}.log`);
-        
-        try {
-          await fs.access(logFilePath);
-        } catch {
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Log file for service "${serviceName}" not found. Ensure the service is running via "nexusflow start".`,
-              },
-            ],
-            isError: true,
-          };
-        }
-
-        const content = await fs.readFile(logFilePath, 'utf8');
-        const logLines = content.split('\n');
-        const tail = logLines.slice(-lines).join('\n');
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: tail || '(empty log)',
-            },
-          ],
-        };
-      } catch (error: any) {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Error reading logs: ${error.message}`,
-            },
-          ],
-          isError: true,
-        };
-      }
-    }
-
-    // Unknown tool
-    throw new Error(`Tool not found: ${name}`);
-  });
-
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}

package/src/orchestration/detect.ts

@@ -1,313 +0,0 @@
-/**
- * @module orchestration/detect
- * Detects how to start each project in a workspace, and finds existing
- * orchestration tools (Docker Compose, .NET Aspire, etc.).
- */
-
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-
-import type { ServiceConfig, OrchestrationDetection } from '../types.js';
-
-/**
- * Detects existing orchestration tool configs in a directory.
- *
- * @param dir - Directory to scan (workspace root or repo root).
- * @returns Array of detected orchestration tools.
- */
-export async function detectOrchestrationTools(
-  dir: string,
-): Promise<OrchestrationDetection[]> {
-  const results: OrchestrationDetection[] = [];
-
-  async function scan(folder: string, prefix = '') {
-    // Docker Compose
-    const composeFiles = ['docker-compose.yml', 'docker-compose.yaml', 'compose.yaml', 'compose.yml'];
-    for (const file of composeFiles) {
-      const filePath = path.join(folder, file);
-      try {
-        await fs.access(filePath);
-        results.push({
-          tool: 'docker-compose',
-          configPath: filePath,
-          startCommand: `docker compose -f "${prefix ? path.join(prefix, file) : file}" up -d`,
-          stopCommand: `docker compose -f "${prefix ? path.join(prefix, file) : file}" down`,
-        });
-        break; // Only use the first found
-      } catch { /* not found */ }
-    }
-
-    // .NET Aspire (look for *.AppHost directories or *.AppHost.csproj)
-    try {
-      const entries = await fs.readdir(folder);
-      for (const entry of entries) {
-        if (entry.endsWith('.AppHost') || entry.includes('AppHost')) {
-          const entryPath = path.join(folder, entry);
-          const stat = await fs.stat(entryPath);
-          if (stat.isDirectory()) {
-            // Check for .csproj inside
-            const subEntries = await fs.readdir(entryPath);
-            const csproj = subEntries.find((e) => e.endsWith('.csproj'));
-            if (csproj) {
-              const projectPath = prefix ? path.join(prefix, entry, csproj) : path.join(entry, csproj);
-              results.push({
-                tool: 'aspire',
-                configPath: path.join(entryPath, csproj),
-                startCommand: `dotnet run --project "${projectPath}"`,
-                stopCommand: 'Ctrl+C (Aspire runs in foreground)',
-              });
-            }
-          }
-        }
-      }
-    } catch { /* ignore */ }
-
-    // Tilt
-    try {
-      const tiltPath = path.join(folder, 'Tiltfile');
-      await fs.access(tiltPath);
-      results.push({
-        tool: 'tilt',
-        configPath: tiltPath,
-        startCommand: prefix ? `tilt up --file ${path.join(prefix, 'Tiltfile')}` : 'tilt up',
-        stopCommand: prefix ? `tilt down --file ${path.join(prefix, 'Tiltfile')}` : 'tilt down',
-      });
-    } catch { /* not found */ }
-
-    // Procfile
-    try {
-      const procPath = path.join(folder, 'Procfile');
-      await fs.access(procPath);
-      results.push({
-        tool: 'procfile',
-        configPath: procPath,
-        startCommand: prefix ? `honcho start -f ${path.join(prefix, 'Procfile')}` : 'honcho start',
-        stopCommand: 'Ctrl+C',
-      });
-    } catch { /* not found */ }
-
-    // Makefile
-    try {
-      const makePath = path.join(folder, 'Makefile');
-      const content = await fs.readFile(makePath, 'utf-8');
-      if (content.includes('start:') || content.includes('dev:') || content.includes('run:')) {
-        const makeCmd = prefix ? `make -C "${prefix}" dev` : 'make dev';
-        results.push({
-          tool: 'makefile',
-          configPath: makePath,
-          startCommand: makeCmd,
-          stopCommand: 'Ctrl+C',
-        });
-      }
-    } catch { /* not found */ }
-  }
-
-  // Scan root directory
-  await scan(dir);
-
-  // Scan subdirectories
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-        await scan(path.join(dir, entry.name), entry.name);
-      }
-    }
-  } catch { /* ignore */ }
-
-  return results;
-}
-
-/**
- * Detects how to start a single project based on its manifest files.
- *
- * @param projectPath - Absolute path to the project directory.
- * @param projectName - Display name of the project.
- * @returns A ServiceConfig if a start command was detected, null otherwise.
- */
-export async function detectServiceConfig(
-  projectPath: string,
-  projectName: string,
-): Promise<ServiceConfig | null> {
-  // ── Node.js (package.json) ────────────────────────────────────────
-  try {
-    const raw = await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8');
-    const pkg = JSON.parse(raw) as Record<string, unknown>;
-    const scripts = pkg.scripts as Record<string, string> | undefined;
-
-    if (scripts) {
-      // Priority: dev > start > serve
-      const scriptName = scripts['dev'] ? 'dev' : scripts['start'] ? 'start' : scripts['serve'] ? 'serve' : null;
-      if (scriptName) {
-        // Detect port from script content
-        const scriptContent = scripts[scriptName]!;
-        const portMatch = scriptContent.match(/--port\s+(\d+)/i) ?? scriptContent.match(/-p\s+(\d+)/);
-        const port = portMatch ? parseInt(portMatch[1]!, 10) : undefined;
-
-        return {
-          name: projectName,
-          cwd: projectPath,
-          command: 'npm',
-          args: ['run', scriptName],
-          port,
-          source: 'package.json',
-        };
-      }
-    }
-  } catch { /* no package.json */ }
-
-  // ── .NET (*.csproj) ───────────────────────────────────────────────
-  try {
-    const entries = await fs.readdir(projectPath);
-    const csproj = entries.find((e) => e.endsWith('.csproj'));
-    if (csproj) {
-      // Check launchSettings for port
-      let port: number | undefined;
-      try {
-        const raw = await fs.readFile(
-          path.join(projectPath, 'Properties', 'launchSettings.json'),
-          'utf-8',
-        );
-        const settings = JSON.parse(raw) as Record<string, unknown>;
-        const profiles = settings.profiles as Record<string, Record<string, unknown>> | undefined;
-        if (profiles) {
-          const firstProfile = Object.values(profiles)[0];
-          const appUrl = firstProfile?.applicationUrl as string | undefined;
-          if (appUrl) {
-            const portMatch = appUrl.match(/:(\d+)/);
-            if (portMatch) port = parseInt(portMatch[1]!, 10);
-          }
-        }
-      } catch { /* no launchSettings */ }
-
-      return {
-        name: projectName,
-        cwd: projectPath,
-        command: 'dotnet',
-        args: ['run'],
-        port,
-        source: 'dotnet',
-      };
-    }
-  } catch { /* ignore */ }
-
-  // ── Python ────────────────────────────────────────────────────────
-  try {
-    await fs.access(path.join(projectPath, 'manage.py'));
-    return {
-      name: projectName,
-      cwd: projectPath,
-      command: 'python',
-      args: ['manage.py', 'runserver'],
-      port: 8000,
-      source: 'python',
-    };
-  } catch { /* not Django */ }
-
-  try {
-    // Check for main.py or app.py (FastAPI/Flask)
-    const hasAppPy = await fs.access(path.join(projectPath, 'app.py')).then(() => true).catch(() => false);
-    const hasMainPy = await fs.access(path.join(projectPath, 'main.py')).then(() => true).catch(() => false);
-
-    if (hasMainPy || hasAppPy) {
-      const entryFile = hasMainPy ? 'main.py' : 'app.py';
-      const content = await fs.readFile(path.join(projectPath, entryFile), 'utf-8');
-
-      if (content.includes('FastAPI') || content.includes('fastapi')) {
-        return {
-          name: projectName,
-          cwd: projectPath,
-          command: 'uvicorn',
-          args: [`${entryFile.replace('.py', '')}:app`, '--reload'],
-          port: 8000,
-          source: 'python',
-        };
-      }
-
-      if (content.includes('Flask') || content.includes('flask')) {
-        return {
-          name: projectName,
-          cwd: projectPath,
-          command: 'python',
-          args: [entryFile],
-          port: 5000,
-          source: 'python',
-        };
-      }
-    }
-  } catch { /* ignore */ }
-
-  // ── Go ────────────────────────────────────────────────────────────
-  try {
-    await fs.access(path.join(projectPath, 'go.mod'));
-    return {
-      name: projectName,
-      cwd: projectPath,
-      command: 'go',
-      args: ['run', '.'],
-      source: 'go',
-    };
-  } catch { /* no go.mod */ }
-
-  // ── Makefile ──────────────────────────────────────────────────────
-  try {
-    const content = await fs.readFile(path.join(projectPath, 'Makefile'), 'utf-8');
-    if (content.includes('dev:')) {
-      return { name: projectName, cwd: projectPath, command: 'make', args: ['dev'], source: 'makefile' };
-    }
-    if (content.includes('run:')) {
-      return { name: projectName, cwd: projectPath, command: 'make', args: ['run'], source: 'makefile' };
-    }
-  } catch { /* no Makefile */ }
-
-  return null;
-}
-
-/**
- * Detects service configs for all projects in a workspace.
- *
- * @param workspacePath - Absolute path to the workspace root.
- * @returns Array of detected ServiceConfig objects.
- */
-export async function detectAllServices(
-  workspacePath: string,
-): Promise<ServiceConfig[]> {
-  const services: ServiceConfig[] = [];
-
-  let entries: import('node:fs').Dirent[];
-  try {
-    entries = await fs.readdir(workspacePath, { withFileTypes: true });
-  } catch {
-    return services;
-  }
-
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    // Skip hidden dirs and known non-project dirs
-    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-
-    const projectPath = path.join(workspacePath, entry.name);
-    const config = await detectServiceConfig(projectPath, entry.name);
-    if (config) {
-      services.push(config);
-      continue;
-    }
-
-    // If no config at the root, check first-level subdirectories of this project (e.g. nested packages)
-    try {
-      const subEntries = await fs.readdir(projectPath, { withFileTypes: true });
-      for (const subEntry of subEntries) {
-        if (!subEntry.isDirectory()) continue;
-        if (subEntry.name.startsWith('.') || subEntry.name === 'node_modules') continue;
-
-        const subProjectPath = path.join(projectPath, subEntry.name);
-        const subConfig = await detectServiceConfig(subProjectPath, `${entry.name}/${subEntry.name}`);
-        if (subConfig) {
-          services.push(subConfig);
-        }
-      }
-    } catch { /* ignore read errors */ }
-  }
-
-  return services;
-}

package/src/orchestration/index.ts

@@ -1,7 +0,0 @@
-/**
- * @module orchestration/index
- * Re-exports all orchestration modules.
- */
-
-export { detectOrchestrationTools, detectServiceConfig, detectAllServices } from './detect.js';
-export { startServices, stopServices, getServiceStatus, showLogs, loadRunningState } from './runner.js';