refactor: refactor project root resolution

- Remove code duplication
- Add tests

Author: Genyus

packages/swarm/src/mcp/cli/server-manager.test.ts

@@ -1,3 +1,5 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { ServerManager } from './server-manager';
 
@@ -6,6 +8,15 @@ vi.mock('../server/mcp-manager', () => ({
   MCPManager: vi.fn(),
 }));
 
+// Mock node:fs
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return {
+    ...actual,
+    existsSync: vi.fn(),
+  };
+});
+
 // Mock logger
 vi.mock('../server/utils', async (importOriginal) => ({
   ...(await importOriginal()),
@@ -222,4 +233,257 @@ describe('ServerManager', () => {
       await expect(serverManager.stop()).resolves.toBeUndefined();
     });
   });
+
+  describe('resolveProjectRoot', () => {
+    let originalCwd: string;
+    let originalArgv: string[];
+    const mockedExistsSync = vi.mocked(existsSync);
+
+    beforeEach(() => {
+      originalCwd = process.cwd();
+      originalArgv = [...process.argv];
+      mockedExistsSync.mockReset();
+    });
+
+    afterEach(() => {
+      vi.spyOn(process, 'cwd').mockRestore();
+      process.argv = originalArgv;
+    });
+
+    /**
+     * Helper to invoke private resolveProjectRoot method
+     */
+    function invokeResolveProjectRoot(manager: ServerManager): string {
+      return (manager as any).resolveProjectRoot();
+    }
+
+    describe('when cwd is a valid project root', () => {
+      it('should return cwd when swarm.config.json exists', () => {
+        const projectDir = '/users/dev/my-project';
+        vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          return filePath === path.join(projectDir, 'swarm.config.json');
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(projectDir);
+      });
+
+      it('should return cwd when package.json exists', () => {
+        const projectDir = '/users/dev/my-project';
+        vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          return filePath === path.join(projectDir, 'package.json');
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(projectDir);
+      });
+
+      it('should prioritize swarm.config.json check (short-circuit)', () => {
+        const projectDir = '/users/dev/my-project';
+        vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          // Both files exist
+          return (
+            filePath === path.join(projectDir, 'swarm.config.json') ||
+            filePath === path.join(projectDir, 'package.json')
+          );
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(projectDir);
+      });
+    });
+
+    describe('when cwd is not a project root (binary path fallback)', () => {
+      it('should resolve from node_modules parent when binary is locally installed', () => {
+        const cwdDir = '/tmp/random-dir';
+        const projectRoot = '/users/dev/my-project';
+        const binaryPath = `${projectRoot}/node_modules/.bin/swarm`;
+
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node', binaryPath];
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          // cwd has no project files
+          if (
+            filePath === path.join(cwdDir, 'swarm.config.json') ||
+            filePath === path.join(cwdDir, 'package.json')
+          ) {
+            return false;
+          }
+          // project root has swarm.config.json
+          return filePath === path.join(projectRoot, 'swarm.config.json');
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(projectRoot);
+      });
+
+      it('should resolve from deep node_modules path', () => {
+        const cwdDir = '/tmp/random-dir';
+        const projectRoot = '/users/dev/monorepo/packages/my-app';
+        const binaryPath = `${projectRoot}/node_modules/@ingenyus/swarm/bin/swarm`;
+
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node', binaryPath];
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          // cwd has no project files
+          if (
+            filePath === path.join(cwdDir, 'swarm.config.json') ||
+            filePath === path.join(cwdDir, 'package.json')
+          ) {
+            return false;
+          }
+          // project root has package.json
+          return filePath === path.join(projectRoot, 'package.json');
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(projectRoot);
+      });
+
+      it('should use lastIndexOf to find the correct node_modules (nested case)', () => {
+        const cwdDir = '/tmp/random-dir';
+        // Simulates a monorepo where binary is in a nested package's node_modules
+        const projectRoot = '/users/dev/monorepo/packages/app';
+        const binaryPath = `${projectRoot}/node_modules/.pnpm/@ingenyus+swarm@1.0.0/node_modules/@ingenyus/swarm/bin/swarm`;
+
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node', binaryPath];
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          if (
+            filePath === path.join(cwdDir, 'swarm.config.json') ||
+            filePath === path.join(cwdDir, 'package.json')
+          ) {
+            return false;
+          }
+          // The project root (before the last node_modules) has swarm.config.json
+          return filePath === path.join(projectRoot, 'swarm.config.json');
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        // Should find the parent of the LAST node_modules (pnpm structure)
+        // In this case: /users/dev/monorepo/packages/app/node_modules/.pnpm/@ingenyus+swarm@1.0.0
+        // But that's not a valid project root, so it falls back to cwd
+        expect(result).toBe(cwdDir);
+      });
+    });
+
+    describe('when binary path does not contain node_modules', () => {
+      it('should fall back to cwd when binary is run directly (development)', () => {
+        const cwdDir = '/users/dev/swarm';
+        const binaryPath = '/users/dev/swarm/bin/swarm';
+
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node', binaryPath];
+
+        mockedExistsSync.mockReturnValue(false);
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(cwdDir);
+      });
+
+      it('should fall back to cwd when using npx remotely', () => {
+        const cwdDir = '/users/dev/my-project';
+        // npx downloads to a temp cache location without node_modules in project path
+        const binaryPath =
+          '/home/user/.npm/_npx/abc123/node_modules/@ingenyus/swarm/bin/swarm';
+
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node', binaryPath];
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          // cwd has no project files
+          if (
+            filePath === path.join(cwdDir, 'swarm.config.json') ||
+            filePath === path.join(cwdDir, 'package.json')
+          ) {
+            return false;
+          }
+          // npx cache parent is not a valid project root
+          return false;
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(cwdDir);
+      });
+    });
+
+    describe('when binary path candidate is not a valid project root', () => {
+      it('should fall back to cwd when node_modules parent has no project files', () => {
+        const cwdDir = '/users/dev/working-dir';
+        const notProjectRoot = '/some/random/location';
+        const binaryPath = `${notProjectRoot}/node_modules/@ingenyus/swarm/bin/swarm`;
+
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node', binaryPath];
+
+        // Neither cwd nor the node_modules parent have project files
+        mockedExistsSync.mockReturnValue(false);
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(cwdDir);
+      });
+    });
+
+    describe('edge cases', () => {
+      it('should handle missing argv[1]', () => {
+        const cwdDir = '/users/dev/my-project';
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = ['node']; // No argv[1]
+
+        mockedExistsSync.mockReturnValue(false);
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(cwdDir);
+      });
+
+      it('should handle empty argv', () => {
+        const cwdDir = '/users/dev/my-project';
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+        process.argv = [];
+
+        mockedExistsSync.mockReturnValue(false);
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(cwdDir);
+      });
+
+      it('should handle Windows-style paths', () => {
+        const cwdDir = 'C:\\Users\\dev\\my-project';
+        vi.spyOn(process, 'cwd').mockReturnValue(cwdDir);
+
+        mockedExistsSync.mockImplementation((filePath) => {
+          // Normalize for comparison (path.join handles this)
+          const normalizedPath = String(filePath);
+          return (
+            normalizedPath === path.join(cwdDir, 'swarm.config.json') ||
+            normalizedPath === path.join(cwdDir, 'package.json')
+          );
+        });
+
+        const result = invokeResolveProjectRoot(serverManager);
+
+        expect(result).toBe(cwdDir);
+      });
+    });
+  });
 });

packages/swarm/src/mcp/cli/server-manager.ts

@@ -115,28 +115,28 @@ export class ServerManager {
     return this.isRunning;
   }
 
+  private isProjectRoot(dir: string): boolean {
+    const pathExists = (dirPath: string, fileName: string) =>
+      existsSync(path.join(dirPath, fileName));
+
+    return (
+      pathExists(dir, 'swarm.config.json') || pathExists(dir, 'package.json')
+    );
+  }
+
   private resolveProjectRoot(): string {
     // Strategy: Try process.cwd() first, then fall back to binary path resolution
     // This handles all scenarios:
     // 1. Local direct path: cwd() is project root
     // 2. External direct path: cwd() is target project root
     // 3. Local npx: cwd() is project root (fixed)
     // 4. Remote npx: cwd() is where command was invoked, then fallback to binary path
-
     const cwd = process.cwd();
 
-    // Check if cwd() looks like a valid project directory
-    const hasSwarmConfig = existsSync(path.join(cwd, 'swarm.config.json'));
-    const hasPackageJson = existsSync(path.join(cwd, 'package.json'));
-
-    if (hasSwarmConfig || hasPackageJson) {
+    if (this.isProjectRoot(cwd)) {
       return cwd;
     }
 
-    // Fallback: Try to infer project root from binary location
-    // This helps when:
-    // - Binary is installed locally in project/node_modules (scenario 1)
-    // - Remote npx but binary happens to be in a project's node_modules
     const binPath = process.argv[1];
 
     if (binPath) {
@@ -148,23 +148,12 @@ export class ServerManager {
         const rootSegments = segments.slice(0, nodeModulesIndex);
         const candidate = rootSegments.join(path.sep);
 
-        // Verify the candidate actually looks like a project root
-        if (candidate) {
-          const candidateHasConfig = existsSync(
-            path.join(candidate, 'swarm.config.json')
-          );
-          const candidateHasPackage = existsSync(
-            path.join(candidate, 'package.json')
-          );
-
-          if (candidateHasConfig || candidateHasPackage) {
-            return candidate;
-          }
+        if (this.isProjectRoot(candidate)) {
+          return candidate;
         }
       }
     }
 
-    // Final fallback: use cwd() (will be used by findProjectRoot() to search upward)
     return cwd;
   }
 }