peaks-loop 4.0.0-beta.14 → 4.0.0-beta.16

package/dist/services/filesystem/file-lock.d.ts

@@ -1,11 +0,0 @@
-export declare class LockTimeoutError extends Error {
-    readonly code = "LOCK_TIMEOUT";
-    readonly lockPath: string;
-    constructor(lockPath: string, attempts: number);
-}
-/**
- * Run `fn` while holding an exclusive lock on a sidecar file at
- * `<filePath>.lock`. The lock is released in `finally` (close fd +
- * unlink lock file). Throws LockTimeoutError after MAX_LOCK_RETRIES.
- */
-export declare function withFileLockSync<T>(filePath: string, fn: () => T): T;

package/dist/services/filesystem/file-lock.js

@@ -1,152 +0,0 @@
-/**
- * Cross-process file lock — sync, atomic, no third-party deps.
- *
- * Used by writeSharedEntry (shared-channel.ts) and appendHeartbeat /
- * markCompleted (dispatch-record-writer.ts) to guard the
- * read-modify-write sequence against lost updates from concurrent
- * writers (slice 2026-06-23-audit-3rd finding #2 + #3).
- *
- * Mechanism: write a sidecar `.lock` file next to the target via
- * `fs.openSync(path, 'wx')`. The `wx` flag maps to O_CREAT|O_EXCL on
- * POSIX (atomic) and `CreateFileW(... CREATE_NEW)` on Windows (also
- * atomic). The second opener fails with EEXIST. We retry with capped
- * exponential backoff up to MAX_LOCK_RETRIES, falling through to
- * LOCK_TIMEOUT if the lock cannot be acquired.
- *
- * Stale-lock reaping: a crashed previous holder leaves a `.lock` file
- * behind. We reap locks older than LOCK_STALE_MS by unlinking before
- * retrying. This trades a one-time stale-lock window for bounded
- * recovery without leaking orphan locks.
- *
- * Why not fs.flock? Node's `fs.flock` is POSIX-only; on Windows it
- * throws ERR_FEATURE_UNAVAILABLE_ON_PLATFORM. The `.lock` file
- * pattern works uniformly across platforms and survives process
- * crashes (the file remains; the next acquirer reaps it).
- */
-import { closeSync, existsSync, mkdirSync, openSync, statSync, unlinkSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-const MAX_LOCK_RETRIES = 100;
-const LOCK_RETRY_BASE_MS = 5;
-const LOCK_RETRY_MAX_MS = 50;
-const LOCK_STALE_MS = 30_000;
-export class LockTimeoutError extends Error {
-    code = 'LOCK_TIMEOUT';
-    lockPath;
-    constructor(lockPath, attempts) {
-        super(`LOCK_TIMEOUT: failed to acquire ${lockPath} after ${attempts} retries ` +
-            `(a prior holder may be alive or the lock is stale; it will be reaped ` +
-            `after ${LOCK_STALE_MS}ms of inactivity)`);
-        this.lockPath = lockPath;
-    }
-}
-/**
- * Run `fn` while holding an exclusive lock on a sidecar file at
- * `<filePath>.lock`. The lock is released in `finally` (close fd +
- * unlink lock file). Throws LockTimeoutError after MAX_LOCK_RETRIES.
- */
-export function withFileLockSync(filePath, fn) {
-    const target = resolve(filePath);
-    const lockPath = `${target}.lock`;
-    // Ensure the parent dir exists before openSync('wx') — first-write
-    // callers (e.g. writeSharedEntry on a fresh batch) reach the lock
-    // BEFORE writeAtomic's mkdirSync(dir, { recursive: true }) runs.
-    const dir = dirname(target);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    // Wall-clock guard (slice 014): in pathological slow-system cases, the
-    // retry backoff could push wall-clock above LOCK_STALE_MS. Cap the loop at
-    // LOCK_STALE_MS regardless of attempts; throw the existing LockTimeoutError.
-    //
-    // Slice 2026-07-12-fix note: the slice 014 implementation re-checked
-    // `isStaleLock(lockPath)` at the TOP of every loop iteration. Under
-    // vitest-on-Windows slowdown (each `spinSleep` actually waits hundreds of
-    // ms because of event-loop preemption), the wall clock would cross
-    // `LOCK_STALE_MS` mid-loop and the reaper would unlink a still-fresh
-    // lock — `file-lock.test.ts` "does NOT reap a fresh .lock (<30s old)"
-    // caught this: the lock was reaped at iter ~54 after 30s of retries,
-    // defeating the test that asserts the fresh lock should block. The fix
-    // is to check staleness ONCE, before the loop, and inside the loop
-    // only retry on EEXIST. A crashed previous holder is reaped at entry;
-    // after we begin the retry-backoff phase, the lock is by definition
-    // non-stale (or absent after a race with another reaper), so a stale
-    // check on each iteration only adds risk of spuriously reaping a lock
-    // we just decided was live.
-    const startedAt = Date.now();
-    let attempts = 0;
-    let fd = null;
-    // One-shot stale reap before the loop: if a previous holder crashed and
-    // left the lock older than LOCK_STALE_MS, unlink it now so the first
-    // `openSync(lockPath, 'wx')` attempt can succeed.
-    if (isStaleLock(lockPath)) {
-        try {
-            unlinkSync(lockPath);
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // race: another process reaped it; loop will try to acquire directly.
-        }
-    }
-    while (attempts < MAX_LOCK_RETRIES) {
-        // Wall-clock guard runs at the top of each iteration so a slow retry
-        // backoff (e.g. vitest on Windows) never lets us outlive the stale
-        // threshold and re-enter the reaper branch on a still-live lock.
-        if (Date.now() - startedAt > LOCK_STALE_MS) {
-            throw new LockTimeoutError(lockPath, attempts);
-        }
-        try {
-            fd = openSync(lockPath, 'wx');
-            break;
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== 'EEXIST')
-                throw err;
-            attempts += 1;
-            // Exponential backoff capped at LOCK_RETRY_MAX_MS.
-            const wait = Math.min(LOCK_RETRY_BASE_MS * 2 ** Math.min(attempts, 6), LOCK_RETRY_MAX_MS);
-            spinSleep(wait);
-        }
-    }
-    if (fd === null) {
-        throw new LockTimeoutError(lockPath, attempts);
-    }
-    try {
-        return fn();
-    }
-    finally {
-        try {
-            closeSync(fd);
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // fd may already be closed by the OS on a crash; ignore.
-        }
-        try {
-            unlinkSync(lockPath);
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            // Best-effort: stale .lock is harmless; the next acquirer reaps.
-        }
-    }
-}
-function isStaleLock(lockPath) {
-    try {
-        const s = statSync(lockPath);
-        return Date.now() - s.mtimeMs > LOCK_STALE_MS;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Synchronous sleep via busy-wait. Bounded by MAX_LOCK_RETRIES *
- * LOCK_RETRY_MAX_MS = 5s worst case. The alternative — async sleep —
- * would force every lock consumer to become async, which is a much
- * larger refactor for a slice whose lock contention is rare (concurrent
- * `peaks sub-agent share` for the same batch).
- */
-function spinSleep(ms) {
-    const end = Date.now() + ms;
-    while (Date.now() < end) {
-        /* intentional spin */
-    }
-}

package/dist/services/final-review/final-review-service.d.ts

@@ -1,12 +0,0 @@
-import type { LlmRunner } from '../audit/audit-goal-service.js';
-import type { FinalReviewOutput } from './final-review-types.js';
-export interface PrepareFinalReviewOptions {
-    readonly projectRoot: string;
-    readonly sessionId: string;
-    readonly llmRunner: LlmRunner;
-}
-export declare class IncompleteFinalReviewError extends Error {
-    readonly code: "INCOMPLETE_FINAL_REVIEW";
-    constructor(message: string);
-}
-export declare function prepareFinalReview(rid: string, opts: PrepareFinalReviewOptions): Promise<FinalReviewOutput>;

package/dist/services/final-review/final-review-service.js

@@ -1,52 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-const REQUIRED_DIMENSIONS = [
-    'functional-completeness',
-    'problem-resolution',
-    'no-new-bugs',
-    'existing-functionality-intact'
-];
-const SYSTEM_PROMPT = `You are preparing a 4-dimension business review for human acceptance. Produce a JSON response with EXACTLY these fields:
-- rid (string)
-- generatedAt (ISO timestamp)
-- dimensions (array of EXACTLY 4 objects, one per dimension: functional-completeness, problem-resolution, no-new-bugs, existing-functionality-intact; each with dimension, verdict (pass | fail | inconclusive), summary, evidence (list of {kind, description, [artifact], [link]}), confidence (high | medium | low))
-- overallSummary (one paragraph)
-- allPass (boolean)
-- needsAttention (list of dimension names that need human attention)
-
-Output ONLY valid JSON, no prose.`;
-export class IncompleteFinalReviewError extends Error {
-    code = 'INCOMPLETE_FINAL_REVIEW';
-    constructor(message) {
-        super(message);
-        this.name = 'IncompleteFinalReviewError';
-    }
-}
-export async function prepareFinalReview(rid, opts) {
-    const auditGoalPath = join(opts.projectRoot, '.peaks', '_runtime', opts.sessionId, 'audit-goal', `${rid}.json`);
-    let approvedGoal;
-    try {
-        approvedGoal = JSON.parse(readFileSync(auditGoalPath, 'utf8'));
-    }
-    catch (err) {
-        throw new Error(`Cannot read approved goal from ${auditGoalPath}: ${err.message}`);
-    }
-    const userPrompt = `Approved goal's success criteria: ${JSON.stringify(approvedGoal.successCriteria)}\n\nPrepare the 4-dim review evidence.`;
-    const response = await opts.llmRunner.call(SYSTEM_PROMPT, userPrompt, {
-        maxTokens: 3000
-    });
-    let parsed;
-    try {
-        parsed = JSON.parse(response.output);
-    }
-    catch (err) {
-        throw new IncompleteFinalReviewError(`LLM output is not valid JSON: ${err.message}`);
-    }
-    const output = parsed;
-    const presentDimensions = new Set(output.dimensions.map((d) => d.dimension));
-    const missing = REQUIRED_DIMENSIONS.filter(d => !presentDimensions.has(d));
-    if (missing.length > 0) {
-        throw new IncompleteFinalReviewError(`Missing required dimensions: ${missing.join(', ')}`);
-    }
-    return output;
-}

package/dist/services/final-review/final-review-types.d.ts

@@ -1,42 +0,0 @@
-/**
- * `prepareFinalReview()` — the 4-dimension business review primitive that gates
- * end-of-workflow human acceptance in the 10% human / 90% LLM workflow.
- *
- * Contract:
- *   - Reads the approved audit-goal JSON from
- *     `.peaks/_runtime/<sessionId>/audit-goal/<rid>.json`.
- *   - Calls an injected `LlmRunner` exactly once with a 4-dim review prompt.
- *   - Parses the LLM output as JSON and validates that the `dimensions`
- *     array covers ALL four required dimensions
- *     (functional-completeness, problem-resolution, no-new-bugs,
- *     existing-functionality-intact).
- *   - Throws `IncompleteFinalReviewError` if the JSON is malformed or any
- *     required dimension is missing. Callers MUST treat this as a gate
- *     failure (return to human for re-prompting) — autonomous work must
- *     never proceed on a partial review.
- */
-export type DimensionKind = 'functional-completeness' | 'problem-resolution' | 'no-new-bugs' | 'existing-functionality-intact';
-export type DimensionVerdict = 'pass' | 'fail' | 'inconclusive';
-export type EvidenceKind = 'test-result' | 'test-coverage' | 'manual-spot-check' | 'pre-post-diff' | 'regression-suite' | 'ac-mapping';
-export type DimensionConfidence = 'high' | 'medium' | 'low';
-export interface EvidenceItem {
-    readonly kind: EvidenceKind;
-    readonly description: string;
-    readonly artifact?: string;
-    readonly link?: string;
-}
-export interface DimensionEvidence {
-    readonly dimension: DimensionKind;
-    readonly verdict: DimensionVerdict;
-    readonly summary: string;
-    readonly evidence: readonly EvidenceItem[];
-    readonly confidence: DimensionConfidence;
-}
-export interface FinalReviewOutput {
-    readonly rid: string;
-    readonly generatedAt: string;
-    readonly dimensions: readonly DimensionEvidence[];
-    readonly overallSummary: string;
-    readonly allPass: boolean;
-    readonly needsAttention: readonly DimensionKind[];
-}

package/dist/services/final-review/final-review-types.js

@@ -1,18 +0,0 @@
-/**
- * `prepareFinalReview()` — the 4-dimension business review primitive that gates
- * end-of-workflow human acceptance in the 10% human / 90% LLM workflow.
- *
- * Contract:
- *   - Reads the approved audit-goal JSON from
- *     `.peaks/_runtime/<sessionId>/audit-goal/<rid>.json`.
- *   - Calls an injected `LlmRunner` exactly once with a 4-dim review prompt.
- *   - Parses the LLM output as JSON and validates that the `dimensions`
- *     array covers ALL four required dimensions
- *     (functional-completeness, problem-resolution, no-new-bugs,
- *     existing-functionality-intact).
- *   - Throws `IncompleteFinalReviewError` if the JSON is malformed or any
- *     required dimension is missing. Callers MUST treat this as a gate
- *     failure (return to human for re-prompting) — autonomous work must
- *     never proceed on a partial review.
- */
-export {};

package/dist/services/job/job-resource-snapshot.d.ts

@@ -1,7 +0,0 @@
-import type { ResourceSnapshot } from './job-types.js';
-/**
- * Collects a coarse-grained snapshot of host + project resources.
- * Numeric ranges are clamped to zod's domain — out-of-range values are clamped, not thrown,
- * so callers can decide what to do.
- */
-export declare function collectResourceSnapshot(jobDir: string): ResourceSnapshot;

package/dist/services/job/job-resource-snapshot.js

@@ -1,75 +0,0 @@
-import os from 'node:os';
-import { readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Collects a coarse-grained snapshot of host + project resources.
- * Numeric ranges are clamped to zod's domain — out-of-range values are clamped, not thrown,
- * so callers can decide what to do.
- */
-export function collectResourceSnapshot(jobDir) {
-    const cpus = os.cpus();
-    const loadAvg = (os.loadavg()[0] ?? 0) / (cpus.length || 1);
-    const cpuPercent = Math.max(0, Math.min(100, loadAvg * 100));
-    const totalMemMb = os.totalmem() / 1024 / 1024;
-    const freeMemMb = os.freemem() / 1024 / 1024;
-    const usedMemMb = Math.max(0, totalMemMb - freeMemMb);
-    const memMb = Math.round(usedMemMb);
-    const diskMb = dirSizeMb(jobDir);
-    // contextRatio is best-effort: pull from the same env-var the v2.13.0 auto-compact uses.
-    const envVal = process.env.CLAUDE_CONTEXT_USAGE_PERCENT;
-    const contextRatio = envVal ? Math.max(0, Math.min(1, Number(envVal) / 100)) : 0;
-    return {
-        capturedAt: new Date().toISOString(),
-        cpuPercent,
-        memMb,
-        diskMb,
-        contextRatio,
-    };
-}
-// Non-enumerable internal attachment for test-time access via
-// `collectResourceSnapshot.dirSizeMb`. NOT a public export — keeps
-// the prod module surface clean per PRD while still allowing
-// targeted AC-1/AC-2/AC-3 unit tests to drive `dirSizeMb` directly.
-Object.defineProperty(collectResourceSnapshot, 'dirSizeMb', {
-    value: dirSizeMb,
-    enumerable: false,
-    writable: false,
-    configurable: false,
-});
-/**
- * Best-effort, non-recursive size of one directory level, in rounded megabytes.
- *
- * - Missing directory → 0.
- * - Per-entry stat failures (race with deletion, EBUSY on Windows) → silently skipped.
- * - When `opts.maxEntries` > 0 and the directory has more entries than the cap,
- *   the returned value is a partial sum (a lower bound), and no further `stat`
- *   calls are issued past the cap. Callers must treat the value as a lower bound.
- * - `opts.maxEntries` defaults to 0 (unbounded, legacy behaviour).
- *
- * NOTE: when maxEntries > 0 and the directory contains more entries than the
- * cap, this is a partial sum. Callers must treat the value as a lower bound.
- */
-function dirSizeMb(dir, opts) {
-    const cap = opts?.maxEntries ?? 0;
-    let total = 0;
-    let index = 0;
-    try {
-        for (const name of readdirSync(dir)) {
-            if (cap > 0 && index >= cap)
-                break;
-            try {
-                total += statSync(join(dir, name)).size;
-            }
-            catch (e) {
-                // best-effort: missing entries (race with deletion) are silently skipped
-                void e;
-            }
-            index++;
-        }
-    }
-    catch (e) {
-        // best-effort: missing dir is treated as 0 bytes
-        void e;
-    }
-    return Math.round(total / 1024 / 1024);
-}

package/dist/services/mut/assert-scanner.d.ts

@@ -1,6 +0,0 @@
-import type { AssertionsReport } from './types.js';
-export interface ScanInput {
-    readonly project: string;
-    readonly testFiles: ReadonlyArray<string>;
-}
-export declare function scanAssertions(input: ScanInput): Promise<AssertionsReport>;

package/dist/services/mut/assert-scanner.js

@@ -1,116 +0,0 @@
-/**
- * Per spec §4.2 验收审计 + §7 阶段二 — 5-pattern weak-assertion AST scan.
- *
- * Hard constraints:
- *   H6 (CLI裁决): every detection is regex/AST-based, not LLM-judged.
- *   KISS: regex matchers on common expect() patterns. Production slice
- *   would migrate to TypeScript Compiler API; v1 ships regex for speed.
- *
- * Weak patterns (5):
- *   - toBeDefined()
- *   - toBeTruthy()
- *   - toEqual(x) where arg === receiver (toEqual-self)
- *   - expect.anything()
- *   - toBe(x) where arg === receiver (toBe-self)
- */
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-const WEAK_PATTERNS = [
-    { pattern: 'toBeDefined', regex: /\.toBeDefined\s*\(\s*\)/g },
-    { pattern: 'toBeTruthy', regex: /\.toBeTruthy\s*\(\s*\)/g },
-    { pattern: 'expect-anything', regex: /expect\.anything\s*\(\s*\)/g },
-    // Self-equality patterns require matched-pair parsing; handled below.
-];
-const TO_EQUAL_SELF = /\.toEqual\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/g;
-const TO_BE_SELF = /\.toBe\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/g;
-async function countAssertions(content) {
-    // Approximate: count expect(...).method( occurrences.
-    // Handle nested parens by finding expect( and matching to a balanced close.
-    let count = 0;
-    const re = /expect\s*\(/g;
-    for (const m of content.matchAll(re)) {
-        let depth = 1;
-        let i = (m.index ?? 0) + m[0].length;
-        while (i < content.length && depth > 0) {
-            const ch = content[i];
-            if (ch === '(')
-                depth++;
-            else if (ch === ')')
-                depth--;
-            i++;
-        }
-        // After balanced expect(...), check for .method( pattern.
-        const tail = content.slice(i);
-        if (/^\s*\.\w+\s*\(/.test(tail)) {
-            count++;
-        }
-    }
-    return count;
-}
-function lineOf(content, offset) {
-    return content.slice(0, offset).split('\n').length;
-}
-export async function scanAssertions(input) {
-    let total = 0;
-    let weak = 0;
-    const byPattern = new Map();
-    for (const file of input.testFiles) {
-        const fullPath = join(input.project, file);
-        const content = await readFile(fullPath, 'utf8');
-        total += await countAssertions(content);
-        for (const { pattern, regex } of WEAK_PATTERNS) {
-            const matches = [...content.matchAll(regex)];
-            if (matches.length > 0) {
-                weak += matches.length;
-                const list = byPattern.get(pattern) ?? [];
-                for (const m of matches) {
-                    const idx = m.index ?? 0;
-                    list.push({ file, line: lineOf(content, idx), code: m[0] });
-                }
-                byPattern.set(pattern, list);
-            }
-        }
-        // toEqual-self: needs receiver extraction.
-        const eqSelf = [...content.matchAll(TO_EQUAL_SELF)];
-        for (const m of eqSelf) {
-            const receiverMatch = content.slice(0, m.index ?? 0).match(/expect\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/g);
-            if (receiverMatch && receiverMatch.length > 0) {
-                const lastReceiver = receiverMatch[receiverMatch.length - 1];
-                const receiverName = lastReceiver?.match(/expect\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/)?.[1];
-                if (receiverName && receiverName === m[1]) {
-                    weak += 1;
-                    const idx = m.index ?? 0;
-                    const list = byPattern.get('toEqual-self') ?? [];
-                    list.push({ file, line: lineOf(content, idx), code: m[0] });
-                    byPattern.set('toEqual-self', list);
-                }
-            }
-        }
-        // toBe-self: same pattern.
-        const beSelf = [...content.matchAll(TO_BE_SELF)];
-        for (const m of beSelf) {
-            const receiverMatch = content.slice(0, m.index ?? 0).match(/expect\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/g);
-            if (receiverMatch && receiverMatch.length > 0) {
-                const lastReceiver = receiverMatch[receiverMatch.length - 1];
-                const receiverName = lastReceiver?.match(/expect\s*\(\s*([a-zA-Z_$][\w$]*)\s*\)/)?.[1];
-                if (receiverName && receiverName === m[1]) {
-                    weak += 1;
-                    const idx = m.index ?? 0;
-                    const list = byPattern.get('toBe-self') ?? [];
-                    list.push({ file, line: lineOf(content, idx), code: m[0] });
-                    byPattern.set('toBe-self', list);
-                }
-            }
-        }
-    }
-    const weakPatterns = [];
-    for (const [pattern, examples] of byPattern.entries()) {
-        weakPatterns.push({ pattern, count: examples.length, examples });
-    }
-    return {
-        totalAssertions: total,
-        weakAssertions: weak,
-        weakRate: total === 0 ? 0 : weak / total,
-        weakPatterns,
-    };
-}

package/dist/services/mut/index.d.ts

@@ -1,8 +0,0 @@
-export { MutReportSchema } from './types.js';
-export { scanAssertions, type ScanInput } from './assert-scanner.js';
-export { runMutation, type RunMutationInput, type RunMutationOutput, type StrykerInvoker, type StrykerRawResult, } from './mut-runner.js';
-export { createProductionStrykerInvoker } from './production-stryker.js';
-export { buildMutReport, type BuildMutInput } from './report-builder.js';
-export { loadMutReport, mutReportPath, MUT_REPORT_RELATIVE_PATH } from './report-loader.js';
-export { DEFAULT_THRESHOLDS, evaluateThresholds, type Thresholds, type ThresholdEvaluation, type ThresholdViolation, type ThresholdViolationKind, } from './thresholds.js';
-export type { MutReportJson, MutationReport, AssertionsReport, WeakPattern, WeakPatternCount, Followup, } from './types.js';

package/dist/services/mut/index.js

@@ -1,7 +0,0 @@
-export { MutReportSchema } from './types.js';
-export { scanAssertions } from './assert-scanner.js';
-export { runMutation, } from './mut-runner.js';
-export { createProductionStrykerInvoker } from './production-stryker.js';
-export { buildMutReport } from './report-builder.js';
-export { loadMutReport, mutReportPath, MUT_REPORT_RELATIVE_PATH } from './report-loader.js';
-export { DEFAULT_THRESHOLDS, evaluateThresholds, } from './thresholds.js';

package/dist/services/mut/mut-runner.d.ts

@@ -1,39 +0,0 @@
-/**
- * Per spec §4.2 验收审计 — Stryker wrapper for TS mutation testing.
- *
- * Hard constraints:
- *   H6 (CLI裁决): invokeStryker is injected; production wires it to
- *       @stryker-mutator/core programmatic API.
- *   DRY: production implementation lives in this file; tests mock the
- *       invokeStryker injection point.
- *   KISS: keep the public surface narrow — input, invoker, output.
- */
-import type { MutationReport } from './types.js';
-export interface StrykerRawResult {
-    readonly mutantsTotal: number;
-    readonly mutantsKilled: number;
-    readonly mutantsSurvived: number;
-    readonly mutantsTimeout: number;
-    readonly perFile: ReadonlyArray<{
-        readonly file: string;
-        readonly killRate: number;
-        readonly survived: ReadonlyArray<{
-            line: number;
-            mutation: string;
-            survivedBecause: string;
-        }>;
-    }>;
-}
-export type StrykerInvoker = (opts: {
-    project: string;
-    testFiles: ReadonlyArray<string>;
-}) => Promise<StrykerRawResult>;
-export interface RunMutationInput {
-    readonly project: string;
-    readonly testFiles: ReadonlyArray<string>;
-    readonly invokeStryker: StrykerInvoker;
-}
-export interface RunMutationOutput {
-    readonly mutation: MutationReport;
-}
-export declare function runMutation(input: RunMutationInput): Promise<RunMutationOutput>;

package/dist/services/mut/mut-runner.js

@@ -1,29 +0,0 @@
-export async function runMutation(input) {
-    let raw;
-    try {
-        raw = await input.invokeStryker({
-            project: input.project,
-            testFiles: input.testFiles,
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Stryker invocation failed: ${message}`);
-    }
-    const killRate = raw.mutantsTotal === 0 ? 0 : raw.mutantsKilled / raw.mutantsTotal;
-    return {
-        mutation: {
-            tool: 'stryker',
-            mutantsTotal: raw.mutantsTotal,
-            mutantsKilled: raw.mutantsKilled,
-            mutantsSurvived: raw.mutantsSurvived,
-            mutantsTimeout: raw.mutantsTimeout,
-            killRate,
-            byFile: raw.perFile.map((f) => ({
-                file: f.file,
-                killRate: f.killRate,
-                survived: f.survived,
-            })),
-        },
-    };
-}

package/dist/services/mut/production-stryker.d.ts

@@ -1,2 +0,0 @@
-import type { StrykerInvoker } from './mut-runner.js';
-export declare function createProductionStrykerInvoker(): StrykerInvoker;

package/dist/services/mut/production-stryker.js

@@ -1,75 +0,0 @@
-/**
- * Production Stryker invoker. Uses @stryker-mutator/core programmatic API.
- * Note: this is a thin wrapper — actual Stryker invocation requires the
- * Stryker config in `stryker.conf.js` to live at the project root.
- */
-import { relative, isAbsolute } from 'node:path';
-export function createProductionStrykerInvoker() {
-    return async ({ project, testFiles: _testFiles }) => {
-        // Lazy-load Stryker so unit tests don't need it installed.
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const Stryker = (await import('@stryker-mutator/core')).Stryker;
-        // Mutation surface is owned by stryker.conf.js. testFiles is a runtime
-        // hint (consumed by the configured testRunner, not by Stryker's `mutate`
-        // field — `mutate` is source files to mutate, never test paths).
-        const stryker = new Stryker({});
-        const mutants = (await stryker.runMutationTest());
-        return normalize(mutants, project);
-    };
-}
-function normalize(mutants, project) {
-    let mutantsKilled = 0;
-    let mutantsSurvived = 0;
-    let mutantsTimeout = 0;
-    for (const m of mutants) {
-        if (m.status === 'Killed')
-            mutantsKilled++;
-        else if (m.status === 'Survived')
-            mutantsSurvived++;
-        else if (m.status === 'Timeout')
-            mutantsTimeout++;
-    }
-    // Bucket mutants by fileName to populate perFile. deriveFollowups iterates
-    // m.byFile to emit per-file followups (e.g. low_kill_rate) — leaving this
-    // empty (as v0 did) silently swallowed those followups in production.
-    const byFile = new Map();
-    for (const m of mutants) {
-        // Stryker 8 returns absolute paths in MutantResult.fileName. Strip the
-        // project root so byFile[].file is repo-relative (e.g. "src/services/loop/...").
-        // path.relative falls back to the absolute path when input is outside
-        // project, which is the safest failure mode.
-        const file = isAbsolute(m.fileName) && m.fileName.startsWith(project)
-            ? relative(project, m.fileName)
-            : m.fileName;
-        let bucket = byFile.get(file);
-        if (!bucket) {
-            bucket = { killed: 0, survived: 0, survivedEntries: [] };
-            byFile.set(file, bucket);
-        }
-        if (m.status === 'Killed')
-            bucket.killed++;
-        else if (m.status === 'Survived') {
-            bucket.survived++;
-            bucket.survivedEntries.push({
-                line: m.location.start.line + 1, // Stryker is 0-based; reports are 1-based.
-                mutation: m.replacement,
-                survivedBecause: m.statusReason ?? '',
-            });
-        }
-    }
-    const perFile = [...byFile.entries()]
-        .map(([file, b]) => {
-        const total = b.killed + b.survived;
-        const killRate = total === 0 ? 0 : b.killed / total;
-        return { file, killRate, survived: b.survivedEntries };
-    })
-        // Stable order for MUT.sig / reports.
-        .sort((a, b) => a.file.localeCompare(b.file));
-    return {
-        mutantsTotal: mutants.length,
-        mutantsKilled,
-        mutantsSurvived,
-        mutantsTimeout,
-        perFile,
-    };
-}