@mutineerjs/mutineer 0.1.1 → 0.2.0

package/dist/runner/__tests__/discover.spec.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import fssync from 'node:fs';
-import { normalizePath } from 'vite';
+import { normalizePath } from '../../utils/normalizePath.js';
 import { autoDiscoverTargetsAndTests } from '../discover.js';
 // Mock Vite server creation to avoid opening a real port during tests
 vi.mock('vite', async () => {

package/dist/runner/changed.js

@@ -2,7 +2,7 @@ import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
-import { normalizePath } from 'vite';
+import { normalizePath } from '../utils/normalizePath.js';
 import { createLogger } from '../utils/logger.js';
 const log = createLogger('changed');
 // Constants

package/dist/runner/config.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { loadConfigFromFile } from 'vite';
 import { createLogger } from '../utils/logger.js';
 // Constants
 const CONFIG_FILENAMES = [
@@ -84,6 +83,7 @@ export async function loadMutineerConfig(cwd, configPath) {
  */
 async function loadTypeScriptConfig(filePath) {
     try {
+        const { loadConfigFromFile } = await import('vite');
         const loaded = await loadConfigFromFile(VITE_CONFIG_OPTIONS, filePath);
         return loaded?.config ?? {};
     }

package/dist/runner/discover.js

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { createRequire } from 'node:module';
 import fg from 'fast-glob';
-import { createServer, normalizePath, } from 'vite';
+import { normalizePath } from '../utils/normalizePath.js';
 import { createLogger } from '../utils/logger.js';
 const TEST_PATTERNS_DEFAULT = [
     '**/*.test.[jt]s?(x)',
@@ -34,38 +35,6 @@ function safeRead(file) {
 function isValidResolvedPath(resolved) {
     return typeof resolved === 'string' && resolved.length > 0;
 }
-/**
- * Resolve an import spec to a normalized id (query stripped).
- * Falls back to the original spec when resolution fails.
- */
-async function resolveId(server, specOrAbs, importer) {
-    if (path.isAbsolute(specOrAbs))
-        return normalizePath(path.resolve(specOrAbs));
-    try {
-        const resolved = await server.pluginContainer.resolveId(specOrAbs, importer);
-        // Extract id from ResolveId result (can be string or object with id property)
-        let candidateId;
-        if (isValidResolvedPath(resolved)) {
-            candidateId = resolved;
-        }
-        else if (resolved && typeof resolved === 'object' && 'id' in resolved) {
-            const { id } = resolved;
-            if (isValidResolvedPath(id))
-                candidateId = id;
-        }
-        // Strip query string and normalize path
-        if (candidateId) {
-            const q = candidateId.indexOf('?');
-            return normalizePath(q >= 0 ? candidateId.slice(0, q) : candidateId);
-        }
-        // Fallback to original spec if resolution failed
-        return normalizePath(specOrAbs);
-    }
-    catch {
-        // Resolver may throw for virtual or unsupported ids; fall back to spec
-        return normalizePath(specOrAbs);
-    }
-}
 function isUnder(anyAbs, rootsAbs) {
     const n = normalizePath(anyAbs);
     return rootsAbs.some((r) => n.startsWith(normalizePath(r)));
@@ -82,20 +51,6 @@ function extractImportSpecs(code) {
     }
     return out;
 }
-async function loadPlugins(exts) {
-    if (!exts.has('.vue'))
-        return [];
-    try {
-        const mod = await import('@vitejs/plugin-vue');
-        const vue = mod.default ?? mod;
-        return typeof vue === 'function' ? [vue()] : [];
-    }
-    catch (err) {
-        const detail = err instanceof Error ? err.message : String(err);
-        log.warn(`Unable to load @vitejs/plugin-vue; Vue SFC imports may fail to resolve (${detail})`);
-        return [];
-    }
-}
 /**
  * Check if a path matches any of the exclude patterns.
  * Patterns are matched against the path relative to root.
@@ -117,35 +72,34 @@ function isExcludedPath(absPath, rootAbs, excludePatterns) {
             : rel.startsWith(pattern);
     });
 }
-export async function autoDiscoverTargetsAndTests(root, cfg) {
-    const rootAbs = path.resolve(root);
-    const sourceRoots = toArray(cfg.source ?? 'src').map((s) => path.resolve(rootAbs, s));
-    const exts = new Set(toArray(cfg.extensions ?? EXT_DEFAULT));
-    const testGlobs = toArray(cfg.testPatterns ?? TEST_PATTERNS_DEFAULT);
-    const excludePatterns = toArray(cfg.excludePaths);
-    // Build ignore patterns for fast-glob
-    const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/.*/**'];
-    const userIgnore = excludePatterns.map((p) => p.endsWith('**') ? p : `${p}/**`);
-    const ignore = [...defaultIgnore, ...userIgnore];
-    // 1) locate tests on disk (absolute paths)
-    const tests = await fg(testGlobs, {
-        cwd: rootAbs,
-        absolute: true,
-        ignore,
-    });
-    if (!tests.length)
-        return { targets: [], testMap: new Map() };
-    const testSet = new Set(tests.map((t) => normalizePath(t)));
-    // 2) Vite server for alias/tsconfig path resolution (no execution)
-    const plugins = await loadPlugins(exts);
+// ---------------------------------------------------------------------------
+// Resolver strategies
+// ---------------------------------------------------------------------------
+/**
+ * Create a Vite-based resolver using a dev server for alias/tsconfig path resolution.
+ * Returns the resolver function and a cleanup function to close the server.
+ */
+async function createViteResolver(rootAbs, exts) {
+    const { createServer } = await import('vite');
+    // Load Vue plugin if needed
+    let plugins = [];
+    if (exts.has('.vue')) {
+        try {
+            const mod = await import('@vitejs/plugin-vue');
+            const vue = mod.default ?? mod;
+            plugins = typeof vue === 'function' ? [vue()] : [];
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            log.warn(`Unable to load @vitejs/plugin-vue; Vue SFC imports may fail to resolve (${detail})`);
+        }
+    }
     const quietLogger = {
         hasWarned: false,
         info() { },
         warn() { },
         warnOnce() { },
         error(msg) {
-            // Vite logs a "WebSocket server error" when it cannot bind the HMR port;
-            // since we run in middleware mode and do not need HMR, silence that noise.
             if (typeof msg === 'string' &&
                 msg.includes('WebSocket server error') &&
                 msg.includes('listen EPERM'))
@@ -165,6 +119,98 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
         server: { middlewareMode: true, hmr: false },
         plugins,
     });
+    const resolve = async (specOrAbs, importer) => {
+        if (path.isAbsolute(specOrAbs))
+            return normalizePath(path.resolve(specOrAbs));
+        try {
+            const resolved = await server.pluginContainer.resolveId(specOrAbs, importer);
+            let candidateId;
+            if (isValidResolvedPath(resolved)) {
+                candidateId = resolved;
+            }
+            else if (resolved && typeof resolved === 'object' && 'id' in resolved) {
+                const { id } = resolved;
+                if (isValidResolvedPath(id))
+                    candidateId = id;
+            }
+            if (candidateId) {
+                const q = candidateId.indexOf('?');
+                return normalizePath(q >= 0 ? candidateId.slice(0, q) : candidateId);
+            }
+            return normalizePath(specOrAbs);
+        }
+        catch {
+            return normalizePath(specOrAbs);
+        }
+    };
+    return { resolve, cleanup: () => server.close() };
+}
+const SUPPORTED_EXTENSIONS = ['.ts', '.js', '.tsx', '.jsx', '.vue'];
+/**
+ * Create a Node-based resolver using createRequire for basic module resolution.
+ * Used as a fallback when vite is not installed.
+ */
+function createNodeResolver() {
+    const resolve = async (specOrAbs, importer) => {
+        if (path.isAbsolute(specOrAbs))
+            return normalizePath(path.resolve(specOrAbs));
+        // Skip bare specifiers (packages) — we only care about relative imports
+        if (!specOrAbs.startsWith('.'))
+            return normalizePath(specOrAbs);
+        if (!importer)
+            return normalizePath(specOrAbs);
+        const require = createRequire(importer);
+        try {
+            return normalizePath(require.resolve(specOrAbs));
+        }
+        catch {
+            // Try with different extensions
+            for (const ext of SUPPORTED_EXTENSIONS) {
+                try {
+                    return normalizePath(require.resolve(specOrAbs + ext));
+                }
+                catch {
+                    continue;
+                }
+            }
+            return normalizePath(specOrAbs);
+        }
+    };
+    return { resolve, cleanup: async () => { } };
+}
+/**
+ * Try to create a Vite resolver, falling back to Node resolver if vite is not available.
+ */
+async function createResolver(rootAbs, exts) {
+    try {
+        return await createViteResolver(rootAbs, exts);
+    }
+    catch {
+        log.debug('Vite not available, using Node module resolution for discovery');
+        return createNodeResolver();
+    }
+}
+export async function autoDiscoverTargetsAndTests(root, cfg) {
+    const rootAbs = path.resolve(root);
+    const sourceRoots = toArray(cfg.source ?? 'src').map((s) => path.resolve(rootAbs, s));
+    const exts = new Set(toArray(cfg.extensions ?? EXT_DEFAULT));
+    const testGlobs = toArray(cfg.testPatterns ?? TEST_PATTERNS_DEFAULT);
+    const excludePatterns = toArray(cfg.excludePaths);
+    // Build ignore patterns for fast-glob
+    const defaultIgnore = ['**/node_modules/**', '**/dist/**', '**/.*/**'];
+    const userIgnore = excludePatterns.map((p) => p.endsWith('**') ? p : `${p}/**`);
+    const ignore = [...defaultIgnore, ...userIgnore];
+    // 1) locate tests on disk (absolute paths)
+    const tests = await fg(testGlobs, {
+        cwd: rootAbs,
+        absolute: true,
+        ignore,
+    });
+    if (!tests.length)
+        return { targets: [], testMap: new Map() };
+    const testSet = new Set(tests.map((t) => normalizePath(t)));
+    // 2) Create resolver (Vite if available, otherwise Node-based fallback)
+    const { resolve, cleanup } = await createResolver(rootAbs, exts);
     const targets = new Map();
     const testMap = new Map();
     const contentCache = new Map();
@@ -211,7 +257,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
             const cacheKey = `${absFile}\0${spec}`;
             let resolved = resolveCache.get(cacheKey);
             if (!resolved) {
-                resolved = await resolveId(server, spec, absFile);
+                resolved = await resolve(spec, absFile);
                 resolveCache.set(cacheKey, resolved);
             }
             // vite ids could be URLs; ensure we turn into absolute disk path when possible
@@ -237,7 +283,7 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
             for (const spec of extractImportSpecs(code)) {
                 if (!spec)
                     continue;
-                const resolved = await resolveId(server, spec, testAbs);
+                const resolved = await resolve(spec, testAbs);
                 const next = path.isAbsolute(resolved)
                     ? resolved
                     : normalizePath(path.resolve(rootAbs, resolved));
@@ -253,6 +299,6 @@ export async function autoDiscoverTargetsAndTests(root, cfg) {
         return { targets: Array.from(targets.values()), testMap };
     }
     finally {
-        await server.close();
+        await cleanup();
     }
 }

package/dist/runner/orchestrator.js

@@ -11,7 +11,7 @@
  */
 import path from 'node:path';
 import os from 'node:os';
-import { normalizePath } from 'vite';
+import { normalizePath } from '../utils/normalizePath.js';
 import { render } from 'ink';
 import { createElement } from 'react';
 import { autoDiscoverTargetsAndTests } from './discover.js';

package/dist/types/config.d.ts

@@ -19,13 +19,6 @@ export interface MutineerConfig {
     readonly testPatterns?: readonly string[];
     readonly extensions?: readonly string[];
     readonly autoDiscover?: boolean;
-    /**
-     * Control how Vitest output is handled for mutant runs:
-     * - 'mute' (default) suppresses all output
-     * - 'minimal' echoes only pass/fail summaries
-     * - 'inherit' streams full Vitest output to the CLI
-     */
-    readonly mutantOutput?: 'mute' | 'minimal' | 'inherit';
     readonly minKillPercent?: number;
     /** Preferred test runner (defaults to vitest) */
     readonly runner?: 'vitest' | 'jest';

package/dist/utils/normalizePath.d.ts

@@ -0,0 +1,2 @@
+/** Normalize a file path to use forward slashes (same as vite's normalizePath). */
+export declare function normalizePath(p: string): string;

package/dist/utils/normalizePath.js

@@ -0,0 +1,4 @@
+/** Normalize a file path to use forward slashes (same as vite's normalizePath). */
+export function normalizePath(p) {
+    return p.replace(/\\/g, '/');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutineerjs/mutineer",
-  "version": "v0.1.1",
+  "version": "v0.2.0",
   "type": "module",
   "private": false,
   "bin": {