@mutineerjs/mutineer 0.1.0

package/dist/runner/changed.js

@@ -0,0 +1,210 @@
+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 { createLogger } from '../utils/logger.js';
+const log = createLogger('changed');
+// Constants
+const NULL_SEP = '\0';
+const DEFAULT_BASE_REF = 'main';
+const SUPPORTED_EXTENSIONS = ['.ts', '.js', '.vue'];
+const TEST_FILE_PATTERN = /\.(test|spec)\.(js|ts|vue|mjs|cjs)$/;
+const IMPORT_PATTERN = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g;
+const EXPORT_PATTERN = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
+const REQUIRE_PATTERN = /require\(['"]([^'"]+)['"]\)/g;
+/**
+ * Recursively resolve local file dependencies starting from a source file.
+ * Parses import/export/require statements and follows local references.
+ *
+ * @param file - Path to the file to analyze
+ * @param cwd - Working directory for resolving relative paths
+ * @param seen - Set of already-visited files (to prevent infinite recursion)
+ * @param maxDepth - Maximum depth to recurse (default: 1, meaning direct imports only)
+ * @param currentDepth - Current recursion depth
+ * @returns Array of absolute paths to resolved dependencies
+ */
+function resolveLocalDependencies(file, cwd, seen = new Set(), maxDepth = 1, currentDepth = 0) {
+    // Stop if we've exceeded the max depth
+    if (currentDepth >= maxDepth)
+        return [];
+    // Ignore files that no longer exist (deleted/renamed, etc.)
+    if (!fs.existsSync(file))
+        return [];
+    if (seen.has(file))
+        return [];
+    seen.add(file);
+    let content;
+    try {
+        content = fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        // If the file went missing between existsSync and read, just skip it
+        return [];
+    }
+    const deps = [];
+    const patterns = [IMPORT_PATTERN, EXPORT_PATTERN, REQUIRE_PATTERN];
+    for (const pattern of patterns) {
+        const matches = content.matchAll(pattern);
+        for (const match of matches) {
+            const dep = match[1];
+            if (!dep.startsWith('.'))
+                continue;
+            try {
+                const require = createRequire(file);
+                let resolvedPath;
+                // Try direct resolution first
+                try {
+                    resolvedPath = require.resolve(dep);
+                }
+                catch {
+                    // Try different extensions if direct resolution fails
+                    for (const ext of SUPPORTED_EXTENSIONS) {
+                        try {
+                            // Try replacing existing extension
+                            resolvedPath = require.resolve(dep.replace(/\.(js|ts|vue)$/, ext));
+                            break;
+                        }
+                        catch {
+                            try {
+                                // Try adding extension
+                                resolvedPath = require.resolve(dep + ext);
+                                break;
+                            }
+                            catch {
+                                continue;
+                            }
+                        }
+                    }
+                }
+                if (!resolvedPath) {
+                    log.warn(`Could not resolve path for dependency ${dep} in ${file}`);
+                    continue;
+                }
+                // Skip anything outside the repo/cwd, node_modules, tests, or missing
+                if (!resolvedPath.startsWith(cwd) ||
+                    resolvedPath.includes('node_modules'))
+                    continue;
+                if (TEST_FILE_PATTERN.test(resolvedPath))
+                    continue;
+                if (!fs.existsSync(resolvedPath))
+                    continue;
+                deps.push(normalizePath(resolvedPath));
+                deps.push(...resolveLocalDependencies(resolvedPath, cwd, seen, maxDepth, currentDepth + 1));
+            }
+            catch (err) {
+                log.warn(`Failed to resolve dependency ${dep} in ${file}: ${err}`);
+                continue;
+            }
+        }
+    }
+    return [...new Set(deps)];
+}
+/**
+ * Parse output from git commands using null-separator format.
+ */
+function splitZ(s) {
+    return s.split(NULL_SEP).filter(Boolean);
+}
+/**
+ * Execute a git command and return the output or null if command fails.
+ */
+function runGitCommand(cwd, args) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    return result.status === 0 ? result.stdout : null;
+}
+/**
+ * Find the Git repository root from a given working directory.
+ * Tries multiple candidate directories (passed cwd, INIT_CWD, process.cwd(), PWD).
+ */
+function findRepoContext(passedCwd) {
+    const candidates = [
+        passedCwd,
+        process.env.INIT_CWD,
+        process.cwd(),
+        process.env.PWD,
+    ].filter(Boolean);
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        const output = runGitCommand(resolved, ['rev-parse', '--show-toplevel']);
+        if (output) {
+            return { repoRoot: output.trim(), workingDir: resolved };
+        }
+    }
+    return null;
+}
+/**
+ * List all changed files in a Git repository.
+ *
+ * Returns files that are:
+ * - Committed but not yet in baseRef (compared to baseRef...HEAD)
+ * - Modified but not yet committed (compared to HEAD)
+ * - Untracked but not ignored
+ *
+ * When includeDeps is true, also includes local dependencies of changed files.
+ *
+ * @param cwd - Working directory (will search for repo root if needed)
+ * @param options - Configuration options
+ * @returns Array of absolute paths to changed files
+ */
+export function listChangedFiles(cwd, options = {}) {
+    const repo = findRepoContext(cwd);
+    if (!repo) {
+        const msg = `Mutineer could not locate a Git repository. Checked: ${cwd}, ${process.env.INIT_CWD}, ${process.cwd()}`;
+        if (!options.quiet)
+            log.warn(msg);
+        return [];
+    }
+    const { repoRoot, workingDir } = repo;
+    const baseRef = options.baseRef || DEFAULT_BASE_REF;
+    // Fetch changed files from git
+    const diffCommittedOutput = runGitCommand(repoRoot, [
+        'diff',
+        '-z',
+        '--name-only',
+        '--diff-filter=ACMR',
+        `${baseRef}...HEAD`,
+    ]);
+    const diffWorkingOutput = runGitCommand(repoRoot, [
+        'diff',
+        '-z',
+        '--name-only',
+        '--diff-filter=ACMR',
+        'HEAD',
+    ]);
+    const untrackedOutput = runGitCommand(repoRoot, [
+        'ls-files',
+        '-z',
+        '--others',
+        '--exclude-standard',
+    ]);
+    // If all git commands failed, return empty
+    if (!diffCommittedOutput && !diffWorkingOutput && !untrackedOutput) {
+        return [];
+    }
+    // Merge all changed files from different git sources
+    const rels = [
+        ...(diffCommittedOutput ? splitZ(diffCommittedOutput) : []),
+        ...(diffWorkingOutput ? splitZ(diffWorkingOutput) : []),
+        ...(untrackedOutput ? splitZ(untrackedOutput) : []),
+    ];
+    const out = new Set();
+    for (const p of rels) {
+        const rel = p.replace(/^\.?\//, '');
+        const abs = normalizePath(path.isAbsolute(rel) ? path.normalize(rel) : path.resolve(repoRoot, rel));
+        // Skip deleted / missing
+        if (!fs.existsSync(abs))
+            continue;
+        out.add(abs);
+        if (options.includeDeps && /\.(js|ts|vue|mjs|cjs)$/.test(abs)) {
+            const maxDepth = options.maxDepth ?? 1;
+            const deps = resolveLocalDependencies(abs, workingDir, new Set(), maxDepth);
+            deps.forEach((dep) => out.add(dep));
+        }
+    }
+    return [...out];
+}

package/dist/runner/cleanup.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Clean up all __mutineer__ temp directories created during mutation testing.
+ */
+export declare function cleanupMutineerDirs(cwd: string): Promise<void>;

package/dist/runner/cleanup.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+/**
+ * Clean up all __mutineer__ temp directories created during mutation testing.
+ */
+export async function cleanupMutineerDirs(cwd) {
+    const glob = await import('fast-glob');
+    const dirs = await glob.default('**/__mutineer__', {
+        cwd,
+        onlyDirectories: true,
+        absolute: true,
+        ignore: ['**/node_modules/**'],
+    });
+    for (const dir of dirs) {
+        try {
+            await fs.rm(dir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}

package/dist/runner/config.d.ts

@@ -0,0 +1,13 @@
+import type { MutineerConfig } from '../index.js';
+/**
+ * Loads the Mutineer configuration file.
+ *
+ * Searches for mutineer.config.ts/js/mjs in the project root, or uses a user-provided path.
+ * TypeScript configs are loaded via Vite's loader; JS/MJS configs are imported directly.
+ *
+ * @param cwd - Current working directory to search from
+ * @param configPath - Optional explicit path to the config file
+ * @returns Loaded MutineerConfig (may be partial; defaults applied by caller)
+ * @throws Error if no config file is found or if loading fails
+ */
+export declare function loadMutineerConfig(cwd: string, configPath?: string): Promise<MutineerConfig>;

package/dist/runner/config.js

@@ -0,0 +1,94 @@
+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 = [
+    'mutineer.config.ts',
+    'mutineer.config.js',
+    'mutineer.config.mjs',
+];
+const VITE_CONFIG_OPTIONS = { command: 'build', mode: 'development' };
+const log = createLogger('config');
+/**
+ * Attempt to load and parse a JavaScript/TypeScript module.
+ * @param filePath - Path to the module file
+ * @returns The default export or the module itself
+ * @throws Error if module cannot be loaded
+ */
+async function loadModule(filePath) {
+    const moduleUrl = pathToFileURL(filePath).href;
+    const mod = await import(moduleUrl);
+    return mod.default || mod;
+}
+/**
+ * Validate that the loaded configuration has the expected shape.
+ * While we allow partial configs (defaults applied elsewhere), this ensures
+ * the structure is an object and not some other unexpected type.
+ */
+function validateConfig(config) {
+    if (typeof config !== 'object' && config === null) {
+        return false;
+    }
+    // Config is valid even if empty; defaults are applied elsewhere.
+    // For stricter validation, property-level checks could be added here.
+    return true;
+}
+/**
+ * Loads the Mutineer configuration file.
+ *
+ * Searches for mutineer.config.ts/js/mjs in the project root, or uses a user-provided path.
+ * TypeScript configs are loaded via Vite's loader; JS/MJS configs are imported directly.
+ *
+ * @param cwd - Current working directory to search from
+ * @param configPath - Optional explicit path to the config file
+ * @returns Loaded MutineerConfig (may be partial; defaults applied by caller)
+ * @throws Error if no config file is found or if loading fails
+ */
+export async function loadMutineerConfig(cwd, configPath) {
+    // Build list of candidate file paths to check
+    const candidates = configPath
+        ? [path.resolve(cwd, configPath)]
+        : CONFIG_FILENAMES.map((filename) => path.join(cwd, filename));
+    // Find the first config file that exists
+    const configFile = candidates.find((f) => fs.existsSync(f));
+    if (!configFile) {
+        const suggestion = configPath
+            ? `No config found at ${configPath}`
+            : `No config found in ${cwd}. Expected one of: ${CONFIG_FILENAMES.join(', ')}`;
+        throw new Error(suggestion);
+    }
+    log.debug(`Loading config from: ${configFile}`);
+    try {
+        // Load TypeScript config via Vite, or import JS/MJS directly
+        const loadedConfig = configFile.endsWith('.ts')
+            ? await loadTypeScriptConfig(configFile)
+            : await loadModule(configFile);
+        if (!validateConfig(loadedConfig)) {
+            throw new Error(`Config file does not export a valid configuration object: ${configFile}`);
+        }
+        log.debug('Config loaded successfully:', loadedConfig);
+        return loadedConfig;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to load config from ${configFile}: ${message}`);
+    }
+}
+/**
+ * Load a TypeScript config file using Vite's loader.
+ * @param filePath - Path to the .ts config file
+ * @returns The loaded configuration object
+ * @throws Error if loading fails
+ */
+async function loadTypeScriptConfig(filePath) {
+    try {
+        const loaded = await loadConfigFromFile(VITE_CONFIG_OPTIONS, filePath);
+        return loaded?.config ?? {};
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Cannot load TypeScript config. Ensure 'vite' is installed or rename to .js/.mjs:\n${message}`);
+    }
+}

package/dist/runner/discover.d.ts

@@ -0,0 +1,7 @@
+import type { MutateTarget, MutineerConfig } from '../types/config.js';
+export type TestMap = Map<string, Set<string>>;
+export interface DiscoveryResult {
+    readonly targets: MutateTarget[];
+    readonly testMap: TestMap;
+}
+export declare function autoDiscoverTargetsAndTests(root: string, cfg: MutineerConfig): Promise<DiscoveryResult>;

package/dist/runner/discover.js

@@ -0,0 +1,258 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { createServer, normalizePath, } from 'vite';
+import { createLogger } from '../utils/logger.js';
+const TEST_PATTERNS_DEFAULT = [
+    '**/*.test.[jt]s?(x)',
+    '**/*.spec.[jt]s?(x)',
+];
+const EXT_DEFAULT = ['.vue', '.ts', '.js', '.tsx', '.jsx'];
+// naive but fast: matches `import 'x'` and `import ... from 'x'`
+const IMPORT_RE = /import\s+(?:[^'\"]*from\s+)?['\"]([^'\"]+)['\"]/g;
+const log = createLogger('discover');
+const MAX_CRAWL_DEPTH = 12;
+function toArray(v) {
+    if (Array.isArray(v))
+        return [...v];
+    if (v === null || v === undefined)
+        return [];
+    return [v];
+}
+function safeRead(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Type guard to check if a resolved module is a valid absolute path.
+ * Used to validate Vite plugin resolution results.
+ */
+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)));
+}
+function looksLikeVueScriptSetup(p) {
+    return p.endsWith('.vue');
+}
+/** Extract import specs from source code (fast, regex-based). */
+function extractImportSpecs(code) {
+    const out = [];
+    for (const m of code.matchAll(IMPORT_RE)) {
+        if (m && m[1])
+            out.push(m[1]);
+    }
+    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.
+ */
+function isExcludedPath(absPath, rootAbs, excludePatterns) {
+    if (!excludePatterns.length)
+        return false;
+    const rel = path.relative(rootAbs, absPath);
+    return excludePatterns.some((pattern) => {
+        // Support simple prefix matching (e.g., 'admin' matches 'admin/foo.ts')
+        if (!pattern.includes('*')) {
+            return rel.startsWith(pattern) || rel.startsWith(pattern + path.sep);
+        }
+        // For glob patterns, use fast-glob's isDynamicPattern check and simple matching
+        return fg.isDynamicPattern(pattern)
+            ? new RegExp('^' +
+                pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*') +
+                '(/|$)').test(rel)
+            : 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);
+    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'))
+                return;
+            log.error(typeof msg === 'string' ? msg : String(msg));
+        },
+        clearScreen() { },
+        hasErrorLogged() {
+            return false;
+        },
+    };
+    const server = await createServer({
+        root: rootAbs,
+        logLevel: 'error',
+        customLogger: quietLogger,
+        clearScreen: false,
+        server: { middlewareMode: true, hmr: false },
+        plugins,
+    });
+    const targets = new Map();
+    const testMap = new Map();
+    const contentCache = new Map();
+    const resolveCache = new Map(); // key: importer\0spec -> resolved id
+    async function crawl(absFile, depth, seen, currentTestAbs) {
+        if (depth > MAX_CRAWL_DEPTH)
+            return; // sane guard for huge graphs
+        const key = normalizePath(absFile);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        // @todo is listing node_modules
+        // if this file is within source and has supported extension, register as target mapped to current test
+        const ext = path.extname(absFile);
+        if (exts.has(ext) &&
+            isUnder(absFile, sourceRoots) &&
+            fs.existsSync(absFile) &&
+            !testSet.has(key) &&
+            !isExcludedPath(absFile, rootAbs, excludePatterns)) {
+            if (!targets.has(key)) {
+                targets.set(key, {
+                    file: absFile,
+                    kind: looksLikeVueScriptSetup(absFile)
+                        ? 'vue:script-setup'
+                        : 'module',
+                });
+            }
+            if (!testMap.has(key))
+                testMap.set(key, new Set());
+            testMap.get(key).add(currentTestAbs);
+        }
+        // read file content to find further imports (works for .vue too; imports are inside <script>)
+        let code = contentCache.get(absFile);
+        if (code === undefined) {
+            code = safeRead(absFile);
+            contentCache.set(absFile, code ?? null);
+        }
+        if (!code)
+            return;
+        // find import specs and resolve relative to absFile
+        for (const spec of extractImportSpecs(code)) {
+            if (!spec)
+                continue;
+            const cacheKey = `${absFile}\0${spec}`;
+            let resolved = resolveCache.get(cacheKey);
+            if (!resolved) {
+                resolved = await resolveId(server, spec, absFile);
+                resolveCache.set(cacheKey, resolved);
+            }
+            // vite ids could be URLs; ensure we turn into absolute disk path when possible
+            const next = path.isAbsolute(resolved)
+                ? resolved
+                : normalizePath(path.resolve(rootAbs, resolved));
+            // skip node_modules and virtual ids
+            if (next.includes('/node_modules/'))
+                continue;
+            if (!path.isAbsolute(next))
+                continue;
+            await crawl(next, depth + 1, seen, currentTestAbs);
+        }
+    }
+    try {
+        for (const testAbs of tests) {
+            const seen = new Set();
+            // prime with the test's own direct imports
+            const code = safeRead(testAbs);
+            if (!code)
+                continue;
+            const firstHop = [];
+            for (const spec of extractImportSpecs(code)) {
+                if (!spec)
+                    continue;
+                const resolved = await resolveId(server, spec, testAbs);
+                const next = path.isAbsolute(resolved)
+                    ? resolved
+                    : normalizePath(path.resolve(rootAbs, resolved));
+                if (!path.isAbsolute(next))
+                    continue;
+                firstHop.push(next);
+            }
+            log.debug(`test ${testAbs} first-hop imports ${firstHop.length}`);
+            for (const abs of firstHop) {
+                await crawl(abs, 0, seen, testAbs);
+            }
+        }
+        return { targets: Array.from(targets.values()), testMap };
+    }
+    finally {
+        await server.close();
+    }
+}

package/dist/runner/jest/__tests__/adapter.spec.d.ts

@@ -0,0 +1 @@
+export {};