opencode-magi 0.10.0 → 0.11.0

package/dist/orchestrator/findings.js

@@ -1,88 +0,0 @@
-import { majorityThreshold } from "./majority";
-function validationFindings(output) {
-    if ("findings" in output)
-        return output.findings;
-    return output.newFindings.map((finding) => ({
-        fix: "Please address this before merging.",
-        issue: finding.body,
-        line: finding.line,
-        path: finding.path,
-        startLine: finding.startLine,
-    }));
-}
-export function reviewFindingTargets(outputs) {
-    return Object.entries(outputs).flatMap(([reviewer, output]) => {
-        if (output.verdict !== "CHANGES_REQUESTED")
-            return [];
-        return validationFindings(output).map((finding, findingIndex) => ({
-            finding,
-            findingIndex,
-            reviewer,
-        }));
-    });
-}
-export function validateFindingVotes(input) {
-    const expected = input.targets.filter((target) => target.reviewer !== input.validator);
-    const expectedKeys = new Set(expected.map((target) => `${target.reviewer}:${target.findingIndex}`));
-    const seen = new Set();
-    for (const vote of input.output.votes) {
-        if (vote.reviewer === input.validator) {
-            throw new Error(`${input.validator} must not vote on its own findings`);
-        }
-        const key = `${vote.reviewer}:${vote.findingIndex}`;
-        if (!expectedKeys.has(key))
-            throw new Error(`unexpected finding vote: ${key}`);
-        if (seen.has(key))
-            throw new Error(`duplicate finding vote: ${key}`);
-        seen.add(key);
-    }
-    for (const target of expected) {
-        const key = `${target.reviewer}:${target.findingIndex}`;
-        if (!seen.has(key))
-            throw new Error(`missing finding vote: ${key}`);
-    }
-}
-export function applyFindingValidation(input) {
-    const threshold = majorityThreshold(input.reviewerKeys.length);
-    const kept = [];
-    const discarded = [];
-    const next = {};
-    for (const [reviewer, output] of Object.entries(input.outputs)) {
-        if (output.verdict !== "CHANGES_REQUESTED") {
-            next[reviewer] = output;
-            continue;
-        }
-        const keptIndexes = new Set();
-        const findings = validationFindings(output);
-        findings.forEach((finding, findingIndex) => {
-            let agrees = 1;
-            for (const validator of input.reviewerKeys) {
-                if (validator === reviewer)
-                    continue;
-                const vote = input.validations[validator]?.votes.find((item) => item.reviewer === reviewer && item.findingIndex === findingIndex);
-                if (vote?.vote === "AGREE")
-                    agrees += 1;
-            }
-            const target = { finding, findingIndex, reviewer };
-            if (agrees >= threshold) {
-                kept.push(target);
-                keptIndexes.add(findingIndex);
-                return;
-            }
-            discarded.push(target);
-        });
-        if ("findings" in output) {
-            const keptFindings = output.findings.filter((_finding, index) => keptIndexes.has(index));
-            next[reviewer] = keptFindings.length
-                ? { ...output, findings: keptFindings }
-                : { findings: [], verdict: "MERGE" };
-            continue;
-        }
-        const newFindings = output.newFindings.filter((_finding, index) => keptIndexes.has(index));
-        next[reviewer] =
-            newFindings.length || output.followUps.length
-                ? { ...output, newFindings }
-                : { ...output, newFindings, verdict: "MERGE" };
-    }
-    return { outputs: next, summary: { discarded, kept } };
-}

package/dist/orchestrator/inline-comments.js

@@ -1,73 +0,0 @@
-function parseDiffPath(value) {
-    if (value === "/dev/null")
-        return undefined;
-    let path = value;
-    if (path.startsWith('"') && path.endsWith('"')) {
-        try {
-            path = JSON.parse(path);
-        }
-        catch {
-            path = path.slice(1, -1);
-        }
-    }
-    return path.startsWith("b/") ? path.slice(2) : path;
-}
-function addTargetLine(targets, path, line) {
-    const lines = targets.get(path) ?? new Set();
-    lines.add(line);
-    targets.set(path, lines);
-}
-export function parseRightSideDiffTargets(diff) {
-    const targets = new Map();
-    let currentPath;
-    let rightLine;
-    for (const line of diff.split("\n")) {
-        if (line.startsWith("+++ ")) {
-            currentPath = parseDiffPath(line.slice(4));
-            rightLine = undefined;
-            continue;
-        }
-        if (line.startsWith("@@ ")) {
-            const match = line.match(/\+(\d+)(?:,\d+)?/);
-            rightLine = match ? Number(match[1]) : undefined;
-            continue;
-        }
-        if (!currentPath || rightLine == null)
-            continue;
-        if (line.startsWith("+") || line.startsWith(" ")) {
-            addTargetLine(targets, currentPath, rightLine);
-            rightLine += 1;
-            continue;
-        }
-        if (line.startsWith("-"))
-            continue;
-    }
-    return targets;
-}
-function assertPositiveInteger(value, name) {
-    if (!Number.isInteger(value) || value < 1) {
-        throw new Error(`${name} must be a positive integer`);
-    }
-}
-export function validateInlineCommentTargets(findings, targets, label = "findings") {
-    for (const [index, finding] of findings.entries()) {
-        const name = `${label}[${index}]`;
-        assertPositiveInteger(finding.line, `${name}.line`);
-        if (finding.startLine != null) {
-            assertPositiveInteger(finding.startLine, `${name}.startLine`);
-            if (finding.startLine > finding.line) {
-                throw new Error(`${name}.startLine must be before or equal to line`);
-            }
-        }
-        const lines = targets.get(finding.path);
-        if (!lines) {
-            throw new Error(`${name} targets ${finding.path}:${finding.line}, but path is not in the PR diff`);
-        }
-        const startLine = finding.startLine ?? finding.line;
-        for (let line = startLine; line <= finding.line; line += 1) {
-            if (!lines.has(line)) {
-                throw new Error(`${name} targets ${finding.path}:${line}, but line is not in a right-side PR diff hunk`);
-            }
-        }
-    }
-}

package/dist/orchestrator/majority.js

@@ -1,62 +0,0 @@
-const VERDICTS = ["MERGE", "CHANGES_REQUESTED", "CLOSE"];
-export function majorityThreshold(total) {
-    return Math.floor(total / 2) + 1;
-}
-export function aggregateStringMajority(results, votes) {
-    if (results.length < 3 || results.length % 2 === 0) {
-        throw new Error("majority requires an odd number of at least 3 results");
-    }
-    const counts = Object.fromEntries(votes.map((vote) => [vote, 0]));
-    const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
-    for (const result of results) {
-        counts[result.vote] += 1;
-        voters[result.vote].push(result.voter);
-    }
-    const threshold = majorityThreshold(results.length);
-    const vote = votes.find((item) => counts[item] >= threshold);
-    return { counts, threshold, vote, voters };
-}
-export function aggregateMajority(results) {
-    if (results.length < 3 || results.length % 2 === 0) {
-        throw new Error("majority requires an odd number of at least 3 reviewer results");
-    }
-    const counts = {
-        CHANGES_REQUESTED: 0,
-        CLOSE: 0,
-        MERGE: 0,
-    };
-    const reviewers = {
-        CHANGES_REQUESTED: [],
-        CLOSE: [],
-        MERGE: [],
-    };
-    for (const result of results) {
-        counts[result.verdict] += 1;
-        reviewers[result.verdict].push(result.reviewer);
-    }
-    const threshold = majorityThreshold(results.length);
-    const verdict = VERDICTS.find((item) => counts[item] >= threshold);
-    if (!verdict)
-        throw new Error("no majority verdict");
-    return { counts, reviewers, threshold, verdict };
-}
-export function reviewOutputsToVerdicts(outputs) {
-    return Object.entries(outputs).map(([reviewer, output]) => ({
-        reviewer,
-        verdict: output.verdict,
-    }));
-}
-export function mergeVerdictForPolicy(results, policy) {
-    const majority = aggregateMajority(results);
-    if (majority.verdict === "CLOSE")
-        return "CLOSE";
-    if (policy === "majority")
-        return majority.verdict;
-    return majority.counts.MERGE === results.length
-        ? "MERGE"
-        : "CHANGES_REQUESTED";
-}
-export function closeMinorityReviewers(results) {
-    const majority = aggregateMajority(results);
-    return majority.verdict === "CLOSE" ? [] : majority.reviewers.CLOSE;
-}