peaks-loop 4.0.0-beta.9 → 4.0.1

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

@@ -1,21 +0,0 @@
-/**
- * Per spec §4.2 验收审计 — Default thresholds + evaluator.
- *
- * Override via `peaks-mut.config.json` at project root.
- */
-export interface Thresholds {
-    readonly mutationKillRateMin: number;
-    readonly weakAssertionRateMax: number;
-}
-export declare const DEFAULT_THRESHOLDS: Thresholds;
-export type ThresholdViolationKind = 'mutationKillRateMin' | 'weakAssertionRateMax';
-export interface ThresholdViolation {
-    readonly kind: ThresholdViolationKind;
-    readonly actual: number;
-    readonly threshold: number;
-}
-export interface ThresholdEvaluation {
-    readonly passed: boolean;
-    readonly violations: ReadonlyArray<ThresholdViolation>;
-}
-export declare function evaluateThresholds(t: Thresholds, actualKillRate: number, actualWeakRate: number): ThresholdEvaluation;

package/dist/services/mut/thresholds.js

@@ -1,22 +0,0 @@
-export const DEFAULT_THRESHOLDS = Object.freeze({
-    mutationKillRateMin: 0.80,
-    weakAssertionRateMax: 0.05,
-});
-export function evaluateThresholds(t, actualKillRate, actualWeakRate) {
-    const violations = [];
-    if (actualKillRate < t.mutationKillRateMin) {
-        violations.push({
-            kind: 'mutationKillRateMin',
-            actual: actualKillRate,
-            threshold: t.mutationKillRateMin,
-        });
-    }
-    if (actualWeakRate > t.weakAssertionRateMax) {
-        violations.push({
-            kind: 'weakAssertionRateMax',
-            actual: actualWeakRate,
-            threshold: t.weakAssertionRateMax,
-        });
-    }
-    return { passed: violations.length === 0, violations };
-}

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

@@ -1,336 +0,0 @@
-/**
- * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
- *
- * Hard constraints:
- *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
- *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
- */
-import { z } from 'zod';
-export type MutVersion = '1.0';
-export type MutTool = 'stryker' | 'mutmut' | 'go-mutesting';
-export type WeakPattern = 'toBeDefined' | 'toBeTruthy' | 'toEqual-self' | 'expect-anything' | 'toBe-self';
-export interface SurvivedMutant {
-    readonly line: number;
-    readonly mutation: string;
-    readonly survivedBecause: string;
-}
-export interface FileMutationReport {
-    readonly file: string;
-    readonly killRate: number;
-    readonly survived: ReadonlyArray<SurvivedMutant>;
-}
-export interface MutationReport {
-    readonly tool: MutTool;
-    readonly mutantsTotal: number;
-    readonly mutantsKilled: number;
-    readonly mutantsSurvived: number;
-    readonly mutantsTimeout: number;
-    readonly killRate: number;
-    readonly byFile: ReadonlyArray<FileMutationReport>;
-}
-export interface WeakExample {
-    readonly file: string;
-    readonly line: number;
-    readonly code: string;
-}
-export interface WeakPatternCount {
-    readonly pattern: WeakPattern;
-    readonly count: number;
-    readonly examples: ReadonlyArray<WeakExample>;
-}
-export interface AssertionsReport {
-    readonly totalAssertions: number;
-    readonly weakAssertions: number;
-    readonly weakRate: number;
-    readonly weakPatterns: ReadonlyArray<WeakPatternCount>;
-}
-export interface ThresholdsConfig {
-    readonly mutationKillRateMin: number;
-    readonly weakAssertionRateMax: number;
-    readonly passed: boolean;
-}
-export type FollowupSeverity = 'soft' | 'hard';
-export type FollowupIssue = 'low_kill_rate' | 'high_weak_assertions';
-export interface Followup {
-    readonly file: string;
-    readonly issue: FollowupIssue;
-    readonly severity: FollowupSeverity;
-    readonly suggestion: string;
-}
-export interface MutReportJson {
-    readonly version: MutVersion;
-    readonly sha256: string;
-    readonly generatedAt: string;
-    readonly inputSig: string;
-    readonly mutation: MutationReport;
-    readonly assertions: AssertionsReport;
-    readonly thresholds: ThresholdsConfig;
-    readonly followups: ReadonlyArray<Followup>;
-}
-export declare const WeakPatternSchema: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
-export declare const MutReportSchema: z.ZodObject<{
-    version: z.ZodLiteral<"1.0">;
-    sha256: z.ZodString;
-    generatedAt: z.ZodString;
-    inputSig: z.ZodString;
-    mutation: z.ZodObject<{
-        tool: z.ZodEnum<["stryker", "mutmut", "go-mutesting"]>;
-        mutantsTotal: z.ZodNumber;
-        mutantsKilled: z.ZodNumber;
-        mutantsSurvived: z.ZodNumber;
-        mutantsTimeout: z.ZodNumber;
-        killRate: z.ZodNumber;
-        byFile: z.ZodArray<z.ZodObject<{
-            file: z.ZodString;
-            killRate: z.ZodNumber;
-            survived: z.ZodArray<z.ZodObject<{
-                line: z.ZodNumber;
-                mutation: z.ZodString;
-                survivedBecause: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }, {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }, {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    }, {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    }>;
-    assertions: z.ZodObject<{
-        totalAssertions: z.ZodNumber;
-        weakAssertions: z.ZodNumber;
-        weakRate: z.ZodNumber;
-        weakPatterns: z.ZodArray<z.ZodObject<{
-            pattern: z.ZodEnum<["toBeDefined", "toBeTruthy", "toEqual-self", "expect-anything", "toBe-self"]>;
-            count: z.ZodNumber;
-            examples: z.ZodArray<z.ZodObject<{
-                file: z.ZodString;
-                line: z.ZodNumber;
-                code: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                code: string;
-                file: string;
-                line: number;
-            }, {
-                code: string;
-                file: string;
-                line: number;
-            }>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }, {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    }, {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    }>;
-    thresholds: z.ZodObject<{
-        mutationKillRateMin: z.ZodNumber;
-        weakAssertionRateMax: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    }, {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    }>;
-    followups: z.ZodArray<z.ZodObject<{
-        file: z.ZodString;
-        issue: z.ZodEnum<["low_kill_rate", "high_weak_assertions"]>;
-        severity: z.ZodEnum<["soft", "hard"]>;
-        suggestion: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }, {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    version: "1.0";
-    sha256: string;
-    generatedAt: string;
-    inputSig: string;
-    mutation: {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    };
-    assertions: {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    };
-    thresholds: {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    };
-    followups: {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }[];
-}, {
-    version: "1.0";
-    sha256: string;
-    generatedAt: string;
-    inputSig: string;
-    mutation: {
-        tool: "stryker" | "mutmut" | "go-mutesting";
-        killRate: number;
-        mutantsTotal: number;
-        mutantsKilled: number;
-        mutantsSurvived: number;
-        mutantsTimeout: number;
-        byFile: {
-            file: string;
-            killRate: number;
-            survived: {
-                line: number;
-                mutation: string;
-                survivedBecause: string;
-            }[];
-        }[];
-    };
-    assertions: {
-        weakRate: number;
-        totalAssertions: number;
-        weakAssertions: number;
-        weakPatterns: {
-            count: number;
-            examples: {
-                code: string;
-                file: string;
-                line: number;
-            }[];
-            pattern: "toBeDefined" | "toBeTruthy" | "toEqual-self" | "expect-anything" | "toBe-self";
-        }[];
-    };
-    thresholds: {
-        passed: boolean;
-        mutationKillRateMin: number;
-        weakAssertionRateMax: number;
-    };
-    followups: {
-        file: string;
-        severity: "soft" | "hard";
-        issue: "low_kill_rate" | "high_weak_assertions";
-        suggestion: string;
-    }[];
-}>;

package/dist/services/mut/types.js

@@ -1,59 +0,0 @@
-/**
- * Per spec §4.2 验收审计 + §7 阶段二 — MutReportJson v1.0.
- *
- * Hard constraints:
- *   H8 (audit trail hashable): sha256 + inputSig (chain to TACT.sig)
- *   H6 (CLI裁决, not LLM): passed boolean is computed by CLI, not LLM
- */
-import { z } from 'zod';
-export const WeakPatternSchema = z.enum([
-    'toBeDefined', 'toBeTruthy', 'toEqual-self', 'expect-anything', 'toBe-self',
-]);
-export const MutReportSchema = z.object({
-    version: z.literal('1.0'),
-    sha256: z.string().regex(/^[a-f0-9]{64}$/),
-    generatedAt: z.string().datetime(),
-    inputSig: z.string().regex(/^[a-f0-9]{64}$/),
-    mutation: z.object({
-        tool: z.enum(['stryker', 'mutmut', 'go-mutesting']),
-        mutantsTotal: z.number().int().nonnegative(),
-        mutantsKilled: z.number().int().nonnegative(),
-        mutantsSurvived: z.number().int().nonnegative(),
-        mutantsTimeout: z.number().int().nonnegative(),
-        killRate: z.number().min(0).max(1),
-        byFile: z.array(z.object({
-            file: z.string(),
-            killRate: z.number().min(0).max(1),
-            survived: z.array(z.object({
-                line: z.number().int(),
-                mutation: z.string(),
-                survivedBecause: z.string(),
-            })),
-        })),
-    }),
-    assertions: z.object({
-        totalAssertions: z.number().int().nonnegative(),
-        weakAssertions: z.number().int().nonnegative(),
-        weakRate: z.number().min(0).max(1),
-        weakPatterns: z.array(z.object({
-            pattern: WeakPatternSchema,
-            count: z.number().int().nonnegative(),
-            examples: z.array(z.object({
-                file: z.string(),
-                line: z.number().int(),
-                code: z.string(),
-            })),
-        })),
-    }),
-    thresholds: z.object({
-        mutationKillRateMin: z.number().min(0).max(1),
-        weakAssertionRateMax: z.number().min(0).max(1),
-        passed: z.boolean(),
-    }),
-    followups: z.array(z.object({
-        file: z.string(),
-        issue: z.enum(['low_kill_rate', 'high_weak_assertions']),
-        severity: z.enum(['soft', 'hard']),
-        suggestion: z.string(),
-    })),
-});

package/dist/services/providers/minimax-provider-service.d.ts

@@ -1,24 +0,0 @@
-import type { MiniMaxProviderConfig } from '../config/config-types.js';
-export type MiniMaxProviderSmokeOptions = {
-    model?: string;
-};
-export type MiniMaxProviderSmokeResult = {
-    provider: 'minimax';
-    configured: boolean;
-    baseUrlConfigured: boolean;
-    apiKeyConfigured: boolean;
-    endpoint: string;
-    model: string;
-    ok: boolean;
-    status: number;
-    responseText: string | null;
-    summary: string | null;
-};
-export type MiniMaxPromptOptions = {
-    model?: string;
-    prompt: string;
-    successText?: string;
-    successMatch?: 'includes' | 'startsWith';
-};
-export declare function runMiniMaxPrompt(config: MiniMaxProviderConfig, options: MiniMaxPromptOptions, fetchImpl?: typeof fetch): Promise<MiniMaxProviderSmokeResult>;
-export declare function testMiniMaxProvider(config: MiniMaxProviderConfig, options?: MiniMaxProviderSmokeOptions, fetchImpl?: typeof fetch): Promise<MiniMaxProviderSmokeResult>;

package/dist/services/providers/minimax-provider-service.js

@@ -1,143 +0,0 @@
-import { getErrorMessage, redactSensitiveErrorMessage } from '../../shared/result.js';
-const DEFAULT_SMOKE_MODEL = 'MiniMax-M2.7';
-const MINIMAX_API_HOST = 'api.minimaxi.com';
-const SMOKE_PROMPT = 'Output exactly: peaks-ok';
-const SMOKE_EXPECTED_TEXT = 'peaks-ok';
-const MAX_TOKENS = 64;
-const REQUEST_TIMEOUT_MS = 15_000;
-const MAX_MODEL_FIELD_LENGTH = 128;
-const SENSITIVE_MODEL_PATTERNS = [
-    /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/i,
-    /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
-    /\b(?:api[\s_-]?key|token|password|secret)\s*[:=]\s*['\"]?[^\s'\"]{8,}/i,
-    /\bAKIA[0-9A-Z]{16}\b/,
-    /\bAIza[0-9A-Za-z_-]{20,}\b/,
-    /\bghp_[0-9A-Za-z_]{20,}\b/,
-    /\bgithub_pat_[0-9A-Za-z_]{20,}\b/,
-    /\bglpat-[0-9A-Za-z_-]{20,}\b/,
-    /\bxox[abprse]-[0-9A-Za-z-]{20,}\b/,
-    /\bsk-[A-Za-z0-9_-]{16,}\b/,
-    /\beyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/
-];
-function getHttpsBaseUrl(value) {
-    try {
-        const url = new URL(value);
-        return url.protocol === 'https:' && url.hostname === MINIMAX_API_HOST && url.username.length === 0 && url.password.length === 0 && url.search.length === 0 && url.hash.length === 0 ? url : null;
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}
-function buildMessagesEndpoint(baseUrl) {
-    return new URL('v1/messages', baseUrl.toString().endsWith('/') ? baseUrl : `${baseUrl.toString()}/`).toString();
-}
-function normalizeModel(model) {
-    const normalized = model?.trim() || DEFAULT_SMOKE_MODEL;
-    if (normalized.length > MAX_MODEL_FIELD_LENGTH) {
-        throw new Error(`model must be ${MAX_MODEL_FIELD_LENGTH} characters or less`);
-    }
-    if (SENSITIVE_MODEL_PATTERNS.some((pattern) => pattern.test(normalized))) {
-        throw new Error('Model contains possible sensitive material and was not sent to MiniMax');
-    }
-    return normalized;
-}
-function getProviderConfigStatus(config) {
-    const baseUrl = config.baseUrl?.trim();
-    const apiKey = config.apiKey?.trim();
-    const baseUrlConfigured = typeof baseUrl === 'string' && baseUrl.length > 0 && getHttpsBaseUrl(baseUrl) !== null;
-    const apiKeyConfigured = typeof apiKey === 'string' && apiKey.length > 0;
-    return {
-        configured: baseUrlConfigured && apiKeyConfigured,
-        baseUrlConfigured,
-        apiKeyConfigured
-    };
-}
-function extractResponseText(value) {
-    if (value === null || typeof value !== 'object')
-        return null;
-    const content = value.content;
-    if (!Array.isArray(content))
-        return null;
-    const textParts = content
-        .filter((item) => item !== null && typeof item === 'object' && item.type === 'text' && typeof item.text === 'string')
-        .map((item) => item.text)
-        .filter((text) => text.trim().length > 0);
-    return textParts.length > 0 ? textParts.join('') : null;
-}
-function createSmokeResult(configStatus, endpoint, model, fields) {
-    return {
-        provider: 'minimax',
-        ...configStatus,
-        endpoint,
-        model,
-        ...fields,
-        summary: fields.responseText === null ? null : fields.responseText.length > 120 ? `${fields.responseText.slice(0, 117)}...` : fields.responseText
-    };
-}
-function createErrorSmokeResult(configStatus, endpoint, model, error) {
-    return {
-        provider: 'minimax',
-        ...configStatus,
-        endpoint,
-        model,
-        ok: false,
-        status: 0,
-        responseText: null,
-        summary: redactSensitiveErrorMessage(getErrorMessage(error))
-    };
-}
-export async function runMiniMaxPrompt(config, options, fetchImpl = fetch) {
-    const baseUrl = config.baseUrl?.trim();
-    const apiKey = config.apiKey?.trim();
-    const configStatus = getProviderConfigStatus(config);
-    const model = normalizeModel(options.model);
-    const httpsBaseUrl = baseUrl ? getHttpsBaseUrl(baseUrl) : null;
-    const endpoint = httpsBaseUrl ? buildMessagesEndpoint(httpsBaseUrl) : '';
-    if (!baseUrl || !apiKey || !httpsBaseUrl) {
-        return createSmokeResult(configStatus, endpoint, model, { ok: false, status: 0, responseText: null });
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-    try {
-        const response = await fetchImpl(endpoint, {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-                'x-api-key': apiKey,
-                'anthropic-version': '2023-06-01'
-            },
-            body: JSON.stringify({
-                model,
-                max_tokens: MAX_TOKENS,
-                messages: [{ role: 'user', content: options.prompt }]
-            }),
-            signal: controller.signal,
-            redirect: 'error'
-        });
-        const responseJson = await response.json().catch(() => null);
-        const responseText = extractResponseText(responseJson);
-        let hasSuccessText = true;
-        if (options.successText) {
-            if (options.successMatch === 'startsWith') {
-                hasSuccessText = responseText?.trimStart().startsWith(options.successText) === true;
-            }
-            else {
-                hasSuccessText = responseText?.includes(options.successText) === true;
-            }
-        }
-        const ok = response.ok && responseText !== null && hasSuccessText;
-        clearTimeout(timeout);
-        return createSmokeResult(configStatus, endpoint, model, {
-            ok,
-            status: response.status,
-            responseText
-        });
-    }
-    catch (error) {
-        clearTimeout(timeout);
-        return createErrorSmokeResult(configStatus, endpoint, model, error);
-    }
-}
-export async function testMiniMaxProvider(config, options = {}, fetchImpl = fetch) {
-    return runMiniMaxPrompt(config, { ...(options.model !== undefined ? { model: options.model } : {}), prompt: SMOKE_PROMPT, successText: SMOKE_EXPECTED_TEXT }, fetchImpl);
-}

package/dist/services/providers/minimax-worker-service.d.ts

@@ -1,21 +0,0 @@
-import type { MiniMaxProviderConfig } from '../config/config-types.js';
-import { type MiniMaxProviderSmokeResult } from './minimax-provider-service.js';
-export type MiniMaxWorkerRequest = {
-    sessionId: string;
-    goal: string;
-    codingTask: string;
-    unitTestTask: string;
-    model?: string;
-};
-export type MiniMaxWorkerResult = {
-    provider: MiniMaxProviderSmokeResult;
-    reviewHandoff: {
-        model: string;
-        prompt: string;
-    };
-    constraints: {
-        allowShell: false;
-        allowFileWrites: false;
-    };
-};
-export declare function runMiniMaxWorker(config: MiniMaxProviderConfig, request: MiniMaxWorkerRequest, fetchImpl?: typeof fetch): Promise<MiniMaxWorkerResult>;