fix: improve path resolution for npx and non-standard entry points

Closes #82

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: QuantGeekDev

src/loaders/BaseLoader.ts

@@ -26,6 +26,7 @@ export abstract class BaseLoader<T> {
       return dir;
     }
 
+    // 1. Check project root dist/ directory (most common case)
     const projectRoot = process.cwd();
     const distPath = join(projectRoot, 'dist', subdirectory);
 
@@ -34,9 +35,27 @@ export abstract class BaseLoader<T> {
       return distPath;
     }
 
+    // 2. Walk up from the main module (process.argv[1]) to find the subdirectory.
+    //    This handles npx where argv[1] is deep inside a temp/cache directory
+    //    but the package's dist/tools etc. are siblings to the entry point.
     const mainModulePath = process.argv[1];
-    const moduleDir = dirname(mainModulePath);
+    if (mainModulePath) {
+      let searchDir = dirname(mainModulePath);
+      // Search up to 5 levels up from the entry point
+      for (let i = 0; i < 5; i++) {
+        const candidate = join(searchDir, subdirectory);
+        if (existsSync(candidate)) {
+          logger.debug(`Found ${subdirectory} by walking up from argv[1]: ${candidate}`);
+          return candidate;
+        }
+        const parent = dirname(searchDir);
+        if (parent === searchDir) break; // reached filesystem root
+        searchDir = parent;
+      }
+    }
 
+    // 3. Original fallback: derive from module path
+    const moduleDir = mainModulePath ? dirname(mainModulePath) : projectRoot;
     const dir = moduleDir.endsWith('dist')
       ? join(moduleDir, subdirectory)
       : join(moduleDir, 'dist', subdirectory);

tests/loaders/BaseLoader-path-resolution.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import { mkdirSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+describe('BaseLoader path resolution', () => {
+  const testDir = join(tmpdir(), 'mcp-path-test-' + Date.now());
+
+  beforeEach(() => {
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('should find tools directory in dist/ relative to cwd', async () => {
+    // Create a dist/tools directory structure
+    const distToolsDir = join(testDir, 'dist', 'tools');
+    mkdirSync(distToolsDir, { recursive: true });
+
+    // Import ToolLoader dynamically
+    const { ToolLoader } = await import('../../src/loaders/toolLoader.js');
+
+    // Save and override cwd
+    const originalCwd = process.cwd;
+    process.cwd = () => testDir;
+
+    try {
+      const loader = new ToolLoader();
+      // The loader should find the dist/tools directory
+      const hasTools = await loader.hasTools();
+      // No actual tool files, so false, but it shouldn't throw
+      expect(hasTools).toBe(false);
+    } finally {
+      process.cwd = originalCwd;
+    }
+  });
+
+  it('should find tools directory when basePath is explicitly provided', async () => {
+    const toolsDir = join(testDir, 'tools');
+    mkdirSync(toolsDir, { recursive: true });
+
+    const { ToolLoader } = await import('../../src/loaders/toolLoader.js');
+    const loader = new ToolLoader(testDir);
+    const hasTools = await loader.hasTools();
+    expect(hasTools).toBe(false); // no files, but directory resolved correctly
+  });
+
+  it('should handle non-existent directories gracefully', async () => {
+    const { ToolLoader } = await import('../../src/loaders/toolLoader.js');
+    const loader = new ToolLoader('/non/existent/path');
+    const hasTools = await loader.hasTools();
+    expect(hasTools).toBe(false);
+  });
+});