@orangepro/orangepro-mcp 0.1.0

package/dist/local/freshness/changed.js

@@ -0,0 +1,280 @@
+import { behaviorNodes, nodesByKind } from "../graph/factories.js";
+const AREA_SKIP = new Set(["src", "app", "lib", "packages", "tests", "test", "e2e", "__tests__", "spec"]);
+/** Strength order for diff→behavior provenance: import-graph evidence beats heuristics. */
+const KIND_RANK = { area: 0, stem: 1, import: 2, direct: 3 };
+const stronger = (a, b) => (KIND_RANK[a] >= KIND_RANK[b] ? a : b);
+/**
+ * Cap on behaviors surfaced by the coarse directory-area fallback. Precise
+ * (test ↔ changed-file) links are never capped; only the area fallback is, so a
+ * small PR can't match every behavior in a top-level directory (the old bug: a
+ * 5-file PR matched ~794 behaviors).
+ */
+const MAX_AREA_FALLBACK_BEHAVIORS = 50;
+/**
+ * HUB damping for the precise import-derived links: a changed file linked to
+ * more test files than max(floor, fraction-of-all-tests) is shared plumbing
+ * (a constants module, a barrel), not behavior-specific signal — expanding it
+ * would flood PR targeting (Mattermost: a one-line constants.tsx edit linked
+ * 186 test files -> 393 "affected" behaviors). Hubs are excluded from precise
+ * expansion and surfaced as an explanatory action instead.
+ */
+const HUB_FAN_IN_MIN = 20;
+const HUB_FAN_IN_FRACTION = 0.02;
+/** First meaningful path segment, mirroring the analyzer's topArea convention. */
+function topArea(relPath) {
+    const parts = relPath.split("/").filter(Boolean);
+    for (const part of parts.slice(0, Math.max(0, parts.length - 1))) {
+        if (!AREA_SKIP.has(part.toLowerCase()))
+            return part;
+    }
+    return parts.length > 1 ? parts[0] : "core";
+}
+function nodeRole(node) {
+    const role = node.properties.role;
+    return typeof role === "string" ? role : "";
+}
+function nodeFile(node) {
+    const file = node.properties.file;
+    return typeof file === "string" ? file : undefined;
+}
+function nodeArea(node) {
+    const area = node.properties.area;
+    return typeof area === "string" ? area : undefined;
+}
+/**
+ * Map a set of changed files to the behaviors and tests whose grounding may be
+ * invalidated, and produce concrete follow-up actions.
+ *
+ * Metadata only: emits external ids / titles and human-readable guidance, never
+ * source content. The graph is read but never mutated.
+ */
+export function changedImpact(graph, changedFiles, base_ref) {
+    const changedSet = new Set(changedFiles);
+    // ── affected_tests: TestCase nodes whose properties.file changed,
+    //    plus File nodes with role 'test' that themselves changed. ──
+    const affectedTestSet = new Set();
+    const changedTestCaseIds = new Set();
+    for (const tc of nodesByKind(graph, "TestCase")) {
+        const file = nodeFile(tc);
+        if (file && changedSet.has(file)) {
+            affectedTestSet.add(tc.title ?? tc.external_id);
+            changedTestCaseIds.add(tc.external_id);
+        }
+    }
+    for (const fileNode of nodesByKind(graph, "File")) {
+        if (nodeRole(fileNode) === "test" && changedSet.has(fileNode.external_id)) {
+            affectedTestSet.add(fileNode.title ?? fileNode.external_id);
+        }
+    }
+    // ── affected_behaviors: PRECISE (test ↔ changed-file) first; coarse area
+    //    match only as a capped fallback when nothing precise links. ──
+    // A changed CODE file relates to test files via MAY_RELATE_TO (File↔File):
+    // primarily RESOLVED test->source imports from the analyzer's import graph,
+    // with the name-stem heuristic as a secondary fallback — so PR-scoped impact
+    // is import-precise wherever the resolver linked. Links are collected PER
+    // changed file (counting only test-file endpoints, so a changed TEST file's
+    // own source imports are ignored), then HUB-damped: a changed file whose test
+    // fan-in exceeds the threshold is excluded from precise expansion and reported
+    // as an action instead.
+    const testFilePaths = new Set();
+    for (const tc of nodesByKind(graph, "TestCase")) {
+        const file = nodeFile(tc);
+        if (file)
+            testFilePaths.add(file);
+    }
+    // Each MAY_RELATE_TO carries its provenance in evidence_strength: "candidate"
+    // is a RESOLVED test→source import (import-graph evidence); anything else
+    // (currently "weak") is the basename-stem name heuristic. Import beats stem for
+    // the same pair, so a resolved link is never downgraded to a guess.
+    const linksPerChangedFile = new Map();
+    const addLink = (changedFile, other, kind) => {
+        if (!testFilePaths.has(other))
+            return; // only test-file endpoints count
+        let m = linksPerChangedFile.get(changedFile);
+        if (!m)
+            linksPerChangedFile.set(changedFile, (m = new Map()));
+        m.set(other, stronger(m.get(other) ?? kind, kind));
+    };
+    for (const e of graph.candidate_edges) {
+        if (e.relationship_type !== "MAY_RELATE_TO")
+            continue;
+        const kind = e.evidence_strength === "candidate" ? "import" : "stem";
+        if (changedSet.has(e.to_external_id))
+            addLink(e.to_external_id, e.from_external_id, kind);
+        if (changedSet.has(e.from_external_id))
+            addLink(e.from_external_id, e.to_external_id, kind);
+    }
+    const hubThreshold = Math.max(HUB_FAN_IN_MIN, Math.ceil(testFilePaths.size * HUB_FAN_IN_FRACTION));
+    // test file -> strongest provenance among the non-hub changed files reaching it.
+    const relatedTestFileKind = new Map();
+    const hubFiles = [];
+    for (const [file, linkedTests] of linksPerChangedFile) {
+        if (linkedTests.size > hubThreshold) {
+            hubFiles.push({ file, fan_in: linkedTests.size });
+            continue;
+        }
+        for (const [t, kind] of linkedTests) {
+            relatedTestFileKind.set(t, stronger(relatedTestFileKind.get(t) ?? kind, kind));
+        }
+    }
+    hubFiles.sort((a, b) => b.fan_in - a.fan_in);
+    // TestCase external_id -> how the diff reached it. A test whose own file is in
+    // the diff is "direct" (strongest); otherwise it inherits the import/stem kind
+    // of the changed file that links it.
+    const testCaseKind = new Map();
+    for (const id of changedTestCaseIds)
+        testCaseKind.set(id, "direct");
+    if (relatedTestFileKind.size) {
+        for (const tc of nodesByKind(graph, "TestCase")) {
+            const file = nodeFile(tc);
+            if (!file)
+                continue;
+            const kind = relatedTestFileKind.get(file);
+            if (!kind)
+                continue;
+            const prev = testCaseKind.get(tc.external_id);
+            testCaseKind.set(tc.external_id, prev ? stronger(prev, kind) : kind);
+        }
+    }
+    const linkTestCaseIds = new Set(testCaseKind.keys());
+    // Behaviors linked to a changed (or import/stem-related) TestCase via coverage
+    // edges, tagged with the strongest provenance among the test cases reaching them.
+    const behaviorIds = new Set(behaviorNodes(graph).map((b) => b.external_id));
+    const behaviorKind = new Map();
+    const link = (a, b) => {
+        let tc;
+        let beh;
+        if (linkTestCaseIds.has(a) && behaviorIds.has(b))
+            (tc = a), (beh = b);
+        else if (linkTestCaseIds.has(b) && behaviorIds.has(a))
+            (tc = b), (beh = a);
+        if (!tc || !beh)
+            return;
+        const kind = testCaseKind.get(tc) ?? "stem";
+        const prev = behaviorKind.get(beh);
+        behaviorKind.set(beh, prev ? stronger(prev, kind) : kind);
+    };
+    for (const e of graph.edges) {
+        if (e.relationship_type === "TESTED_BY" || e.relationship_type === "COVERS")
+            link(e.from_external_id, e.to_external_id);
+    }
+    for (const e of graph.candidate_edges) {
+        if (e.relationship_type === "MAY_BE_TESTED_BY" || e.relationship_type === "MAY_COVER")
+            link(e.from_external_id, e.to_external_id);
+    }
+    const linkedBehaviors = new Set(behaviorKind.keys());
+    // Always include the precise set (behaviors whose tests cover the changed files).
+    // Then fall back to the coarse directory area ONLY for changed-file areas that no
+    // precise behavior already covers — so a mixed PR doesn't lose its un-test-linked
+    // files (per-area, not all-or-nothing), while a precisely-linked area is never
+    // re-expanded to every behavior in its directory (the #7 over-match).
+    const affectedBehaviorSet = new Set(linkedBehaviors);
+    const preciseAreas = new Set();
+    for (const b of behaviorNodes(graph)) {
+        if (!linkedBehaviors.has(b.external_id))
+            continue;
+        const a = nodeArea(b);
+        if (a)
+            preciseAreas.add(a);
+    }
+    // Hub files are excluded from the area fallback too: their impact is
+    // repo-wide, so re-expanding the hub's directory area would re-create the
+    // very flood the damping removed (a hub-only PR must not area-match).
+    const hubFileSet = new Set(hubFiles.map((h) => h.file));
+    const fallbackAreas = new Set();
+    for (const relPath of changedFiles) {
+        if (hubFileSet.has(relPath))
+            continue;
+        const a = topArea(relPath);
+        if (!preciseAreas.has(a))
+            fallbackAreas.add(a);
+    }
+    let area_truncated = 0;
+    if (fallbackAreas.size > 0) {
+        const areaMatched = behaviorNodes(graph)
+            .filter((b) => {
+            const area = nodeArea(b);
+            return area !== undefined && fallbackAreas.has(area) && !affectedBehaviorSet.has(b.external_id);
+        })
+            .map((b) => b.external_id)
+            .sort();
+        area_truncated = Math.max(0, areaMatched.length - MAX_AREA_FALLBACK_BEHAVIORS);
+        for (const id of areaMatched.slice(0, MAX_AREA_FALLBACK_BEHAVIORS)) {
+            affectedBehaviorSet.add(id);
+            // areaMatched already excludes anything precisely linked, so these are
+            // area-only — never overriding a stronger import/stem/direct tag.
+            if (!behaviorKind.has(id))
+                behaviorKind.set(id, "area");
+        }
+    }
+    const area_fallback = fallbackAreas.size > 0;
+    // ── recommended_actions, tailored by the kinds of files that changed ──
+    const configIds = new Set();
+    for (const cfg of nodesByKind(graph, "ConfigFile"))
+        configIds.add(cfg.external_id);
+    for (const pkg of nodesByKind(graph, "Package"))
+        configIds.add(pkg.external_id);
+    for (const fileNode of nodesByKind(graph, "File")) {
+        if (nodeRole(fileNode) === "config")
+            configIds.add(fileNode.external_id);
+    }
+    const changedConfig = changedFiles.some((f) => configIds.has(f));
+    const changedTest = affectedTestSet.size > 0;
+    const changedCode = changedFiles.some((f) => {
+        const node = graph.nodes.find((n) => n.external_id === f);
+        return node !== undefined && node.kind === "File" && nodeRole(node) === "code";
+    });
+    const recommended_actions = [];
+    const sortedBehaviors = [...affectedBehaviorSet].sort();
+    for (const behaviorId of sortedBehaviors.slice(0, 10)) {
+        recommended_actions.push(`Regenerate or review tests for ${behaviorId}`);
+    }
+    if (sortedBehaviors.length > 10) {
+        recommended_actions.push(`… and ${sortedBehaviors.length - 10} more affected behavior(s) (see affected_behaviors).`);
+    }
+    const areaAdded = affectedBehaviorSet.size - linkedBehaviors.size;
+    if (area_fallback && areaAdded > 0) {
+        recommended_actions.push(`Matched ${areaAdded} behavior(s) by directory area for changed files with no test link` +
+            (area_truncated ? ` (+${area_truncated} more capped — narrow the diff or add tests for precise targeting).` : "."));
+    }
+    for (const hub of hubFiles) {
+        recommended_actions.push(`${hub.file} is linked to ${hub.fan_in} test files (hub import; threshold ${hubThreshold}) — ` +
+            `excluded from precise targeting because its impact is repo-wide, not behavior-specific. ` +
+            `Target specific behaviors directly if this file's change is the point of the PR.`);
+    }
+    if (changedConfig) {
+        recommended_actions.push("Config/package changed: re-check framework assumptions (run update)");
+    }
+    if (changedTest) {
+        recommended_actions.push("Changed tests: re-verify behavior coverage confidence");
+    }
+    if (changedCode && affectedBehaviorSet.size === 0) {
+        recommended_actions.push("Code changed: re-run analyze to refresh symbols and coverage");
+    }
+    // Per-behavior provenance: import-graph evidence (direct/import) vs heuristic
+    // (stem/area). Defaults to "area" only if some path added a behavior without a
+    // tag (shouldn't happen — every affected id is tagged at its source).
+    const affected = [...affectedBehaviorSet].sort();
+    const link_kinds = {};
+    const counts = { direct: 0, import: 0, stem: 0, area: 0 };
+    for (const id of affected) {
+        const k = behaviorKind.get(id) ?? "area";
+        link_kinds[id] = k;
+        counts[k]++;
+    }
+    if (affected.length > 0) {
+        const parts = ["direct", "import", "stem", "area"]
+            .filter((k) => counts[k] > 0)
+            .map((k) => `${counts[k]} ${k}`);
+        recommended_actions.unshift(`Targeting provenance: ${parts.join(", ")} (import-graph evidence is precise; stem/area are heuristic).`);
+    }
+    return {
+        status: "ok",
+        base_ref,
+        changed_files: [...changedFiles].sort(),
+        affected_behaviors: affected,
+        link_kinds,
+        affected_tests: [...affectedTestSet].sort(),
+        recommended_actions
+    };
+}

package/dist/local/freshness/manifest.js

@@ -0,0 +1,35 @@
+/**
+ * Read coarse git provenance for the freshness manifest.
+ *
+ * Metadata only — commit/branch/dirty flag. Returns null when the workspace is
+ * not a git checkout (HEAD cannot be resolved), so freshness still works on
+ * plain directories.
+ */
+export function readGitInfo(git) {
+    const head = git(["rev-parse", "HEAD"]);
+    if (head === null)
+        return null;
+    const commit = head.trim().slice(0, 40);
+    const branchRaw = git(["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branch = branchRaw === null ? undefined : branchRaw.trim();
+    const statusRaw = git(["status", "--porcelain"]);
+    const dirty = statusRaw === null ? undefined : statusRaw.trim().length > 0;
+    return {
+        commit,
+        ...(branch !== undefined ? { branch } : {}),
+        ...(dirty !== undefined ? { dirty } : {})
+    };
+}
+/**
+ * Assemble a freshness manifest from per-file entries and git provenance.
+ *
+ * Copies the file_entries map so the returned manifest never aliases the
+ * caller's input.
+ */
+export function buildManifest(file_entries, git, now) {
+    return {
+        generated_at: now,
+        git,
+        files: { ...file_entries }
+    };
+}

package/dist/local/freshness/status.js

@@ -0,0 +1,30 @@
+/**
+ * Compare the graph's stored manifest (previous snapshot) against the current
+ * per-file entries and report what changed.
+ *
+ * changed_files is the union of added (present now, missing before), removed
+ * (present before, missing now), and modified (present in both with a differing
+ * hash), sorted for stable output.
+ *
+ * state:
+ *  - "missing" when the stored manifest has no files (never analyzed),
+ *  - "fresh"   when nothing changed,
+ *  - "stale"   otherwise.
+ */
+export function computeFreshness(graph, currentEntries) {
+    const previous = graph.manifest.files;
+    const previousKeys = Object.keys(previous);
+    const changed = new Set();
+    for (const [relPath, entry] of Object.entries(currentEntries)) {
+        const prior = previous[relPath];
+        if (!prior || prior.hash !== entry.hash)
+            changed.add(relPath);
+    }
+    for (const relPath of previousKeys) {
+        if (!(relPath in currentEntries))
+            changed.add(relPath);
+    }
+    const changed_files = [...changed].sort();
+    const state = previousKeys.length === 0 ? "missing" : changed_files.length === 0 ? "fresh" : "stale";
+    return { state, changed_files };
+}

package/dist/local/gaps/gaps.js

@@ -0,0 +1,114 @@
+import { behaviorNodes, priorityRank } from "../graph/factories.js";
+import { structurallyUnconfirmable } from "../graph/confirmable.js";
+/**
+ * Test-coverage gap analysis over behavior anchors.
+ *
+ * Surfaces behaviors that are missing concrete acceptance criteria and/or hard
+ * test evidence, so the kit can recommend where to add or generate tests. This
+ * is a *readiness* signal built from metadata only — no source code, prompts, or
+ * heuristic internals leak into the returned structure.
+ */
+const DEFAULT_LIMIT = 10;
+/** Hard test evidence: explicit TESTED_BY/COVERS edge. */
+function hasHardTestEvidence(graph, externalId) {
+    return graph.edges.some((e) => (e.relationship_type === "TESTED_BY" || e.relationship_type === "COVERS") &&
+        (e.from_external_id === externalId || e.to_external_id === externalId));
+}
+/** Weak test evidence: only candidate MAY_BE_TESTED_BY/MAY_COVER. */
+function hasWeakTestEvidence(graph, externalId) {
+    return graph.candidate_edges.some((e) => (e.relationship_type === "MAY_BE_TESTED_BY" || e.relationship_type === "MAY_COVER") &&
+        (e.from_external_id === externalId || e.to_external_id === externalId));
+}
+function testEvidenceFor(graph, externalId) {
+    if (hasHardTestEvidence(graph, externalId))
+        return "covered";
+    if (hasWeakTestEvidence(graph, externalId))
+        return "weak";
+    return "none";
+}
+/** Acceptance criteria via explicit edge OR inline properties. */
+function hasAcceptanceCriteria(graph, node) {
+    const linked = graph.edges.some((e) => e.relationship_type === "HAS_ACCEPTANCE_CRITERION" && e.from_external_id === node.external_id);
+    if (linked)
+        return true;
+    const inline = node.properties.acceptance_criteria;
+    return Array.isArray(inline) && inline.length > 0;
+}
+/** Weakest evidence first, so the most under-tested behaviors surface at the top. */
+const EVIDENCE_RANK = {
+    none: 0,
+    weak: 1,
+    covered: 2
+};
+function reasonFor(testEvidence, hasAc) {
+    const parts = [];
+    if (testEvidence === "none")
+        parts.push("No test evidence linked");
+    else if (testEvidence === "weak")
+        parts.push("Only weak (candidate) test evidence linked");
+    if (!hasAc)
+        parts.push("Missing acceptance criteria");
+    return parts.length > 0 ? parts.join("; ") : "Behavior is fully covered";
+}
+function recommendedActionFor(testEvidence, hasAc) {
+    const parts = [];
+    if (testEvidence === "none")
+        parts.push("Add or generate a test for this behavior");
+    else if (testEvidence === "weak")
+        parts.push("Confirm or strengthen the candidate test link into hard evidence");
+    if (!hasAc)
+        parts.push("Add acceptance criteria to make assertions concrete");
+    return parts.length > 0 ? parts.join("; ") : "No action needed";
+}
+export function findGaps(graph, opts) {
+    const behaviors = behaviorNodes(graph);
+    const totalBehaviors = behaviors.length;
+    // Behaviors whose only tests are e2e/api are NOT structural gaps — a real test
+    // likely exists, we just cannot confirm it by import resolution. Filter them
+    // out of the gap list (stays 3-state) and report the count separately.
+    const nsc = structurallyUnconfirmable(graph);
+    const minRank = opts?.min_priority === undefined ? -1 : priorityRank(opts.min_priority);
+    const limit = opts?.limit ?? DEFAULT_LIMIT;
+    const gaps = [];
+    let notStructurallyConfirmable = 0;
+    for (const node of behaviors) {
+        const priorityValue = String(node.properties.priority ?? "unknown");
+        if (priorityRank(priorityValue) < minRank)
+            continue;
+        if (nsc.has(node.external_id)) {
+            notStructurallyConfirmable++;
+            continue;
+        }
+        const testEvidence = testEvidenceFor(graph, node.external_id);
+        const hasAc = hasAcceptanceCriteria(graph, node);
+        const isGap = testEvidence !== "covered" || hasAc === false;
+        if (!isGap)
+            continue;
+        gaps.push({
+            external_id: node.external_id,
+            title: node.title ?? node.external_id,
+            kind: node.kind,
+            priority: priorityValue,
+            reason: reasonFor(testEvidence, hasAc),
+            has_acceptance_criteria: hasAc,
+            test_evidence: testEvidence,
+            recommended_action: recommendedActionFor(testEvidence, hasAc)
+        });
+    }
+    const sorted = [...gaps].sort((a, b) => {
+        const evidenceDelta = EVIDENCE_RANK[a.test_evidence] - EVIDENCE_RANK[b.test_evidence];
+        if (evidenceDelta !== 0)
+            return evidenceDelta;
+        return priorityRank(b.priority) - priorityRank(a.priority);
+    });
+    return {
+        gaps: sorted.slice(0, limit),
+        total_behaviors: totalBehaviors,
+        ...(notStructurallyConfirmable > 0 ? { not_structurally_confirmable: notStructurallyConfirmable } : {}),
+        ...(totalBehaviors === 0
+            ? {
+                guidance: "No behavior anchors found. Run analyze on a path that contains tests, or add requirements/templates (.csv/.md) via --paths."
+            }
+            : {})
+    };
+}

package/dist/local/generate/buckets.js

@@ -0,0 +1,73 @@
+export const LOCAL_BUCKETS = [
+    "happy_path",
+    "validation_error",
+    "edge_case",
+    "integration_flow",
+    "security_privacy",
+    "regression"
+];
+export const BUCKET_LABEL = {
+    happy_path: "happy path",
+    validation_error: "validation error",
+    edge_case: "edge case",
+    integration_flow: "integration flow",
+    security_privacy: "security / privacy",
+    regression: "regression"
+};
+const SIGNAL_OF = {
+    happy_path: "hasExpectedBehavior",
+    validation_error: "hasValidationEvidence",
+    edge_case: "hasEdgeEvidence",
+    integration_flow: "hasIntegrationEvidence",
+    security_privacy: "hasSecurityEvidence",
+    regression: "hasRegressionEvidence"
+};
+/**
+ * Ordered "slots" per total-test budget. Each slot is a small preference list;
+ * the first evidence-justified, not-yet-chosen bucket in a slot fills it. A slot
+ * with no justified candidate is skipped (no padding). Caps match the existing
+ * generation limits (default 3, max 5).
+ */
+const SLOTS_BY_LIMIT = {
+    1: [["happy_path"]],
+    2: [["happy_path"], ["validation_error", "edge_case"]],
+    3: [["happy_path"], ["validation_error", "edge_case"], ["integration_flow", "regression"]],
+    4: [["happy_path"], ["validation_error"], ["edge_case"], ["integration_flow"]],
+    5: [["happy_path"], ["validation_error"], ["edge_case"], ["integration_flow"], ["security_privacy", "regression"]]
+};
+/**
+ * Choose up to `limit` local buckets, in priority order, that are justified by
+ * the evidence signals. Pure and deterministic. Never pads unjustified buckets.
+ */
+export function selectLocalBuckets(signals, limit) {
+    const L = Math.max(1, Math.min(5, Math.floor(limit) || 1));
+    const slots = SLOTS_BY_LIMIT[L];
+    const chosen = [];
+    for (const slot of slots) {
+        for (const bucket of slot) {
+            if (chosen.includes(bucket))
+                continue;
+            if (signals[SIGNAL_OF[bucket]]) {
+                chosen.push(bucket);
+                break;
+            }
+        }
+    }
+    return chosen;
+}
+const VALIDATION_RE = /\b(invalid|errors?|required|reject(ed|s)?|validation|validate|forbidden|not allowed|unauthorized|400|422|constraint|missing (field|value|required)|bad request|must not)\b/;
+const EDGE_RE = /\b(limits?|empty|nulls?|nullable|boundary|missing data|concurren\w*|stale|retr(y|ies)|timeouts?|edge[\s-]?cases?|maximum|minimum|overflow|underflow|zero|negative|out of range|race condition|duplicate)\b/;
+const INTEGRATION_RE = /\b(routes?|endpoints?|api|https?|requests?|responses?|services?|workflows?|flows?|integration|fetch|client|navigat\w*|pages?|screens?|redirect|webhooks?|pipeline|composable|store)\b/;
+const SECURITY_RE = /\b(auth\w*|permissions?|tokens?|secrets?|pii|privacy|sessions?|invites?|oauth|api[\s-]?keys?|roles?|access control|login|logout|passwords?|credentials?|csrf|xss|encrypt\w*)\b/;
+const REGRESSION_RE = /\b(regressions?|bugs?|incidents?|fixed|broke(n)?|known issue|changelog|hotfix|defects?|reproduc\w*)\b/;
+/** Derive bucket signals from a behavior's evidence. Pure. */
+export function deriveBucketSignals(e) {
+    return {
+        hasExpectedBehavior: e.hasTestableAnchor,
+        hasValidationEvidence: VALIDATION_RE.test(e.corpus),
+        hasEdgeEvidence: EDGE_RE.test(e.corpus),
+        hasIntegrationEvidence: INTEGRATION_RE.test(e.corpus) || e.relatedFiles >= 2 || e.workflowSteps > 0,
+        hasSecurityEvidence: SECURITY_RE.test(e.corpus),
+        hasRegressionEvidence: REGRESSION_RE.test(e.corpus) || e.testNames > 0 || e.inferredFromTests
+    };
+}

package/dist/local/generate/compareJudge.js

@@ -0,0 +1,124 @@
+import { behaviorNodes } from "../graph/factories.js";
+const JUDGE_SYSTEM = [
+    "You are a strict, impartial test-quality judge.",
+    "You are given the testing context (target behaviors, acceptance criteria, and the REAL modules/symbols that exist in the repo) and two candidate test suites:",
+    "A = prompt-only baseline, B = Local KG (graph-grounded).",
+    "Score EACH suite from 0 to 100 on four dimensions:",
+    "- completeness: depth and breadth of meaningful, concrete assertions and scenarios for the behavior.",
+    "- context_awareness: how well it uses the provided behaviors / acceptance criteria / context.",
+    "- accuracy: targets REAL modules/symbols from the provided list; penalize invented or hallucinated imports/APIs.",
+    "- domain_specificity: uses the repo's real domain vocabulary rather than generic placeholders.",
+    "The two suites may test different things — judge each on its own merits against the context; do NOT require them to match.",
+    'Return ONLY JSON: {"baseline":{"completeness":N,"context_awareness":N,"accuracy":N,"domain_specificity":N},"grounded":{"completeness":N,"context_awareness":N,"accuracy":N,"domain_specificity":N},"rationale":"one short sentence"}'
+].join("\n");
+function clampScore(v) {
+    const n = typeof v === "number" ? v : Number(v);
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.min(100, Math.round(n)));
+}
+function coerceDims(value) {
+    const o = (value && typeof value === "object" ? value : {});
+    return {
+        completeness: clampScore(o.completeness),
+        context_awareness: clampScore(o.context_awareness),
+        accuracy: clampScore(o.accuracy),
+        domain_specificity: clampScore(o.domain_specificity)
+    };
+}
+/** Parse the judge's JSON response (tolerant of code fences / surrounding prose). */
+export function parseJudgeResponse(text) {
+    const stripped = text.replace(/```(?:json)?/gi, "");
+    const start = stripped.indexOf("{");
+    const end = stripped.lastIndexOf("}");
+    if (start < 0 || end <= start)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(stripped.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const o = parsed;
+    if (!o.baseline && !o.grounded)
+        return null;
+    return {
+        baseline: coerceDims(o.baseline),
+        grounded: coerceDims(o.grounded),
+        rationale: typeof o.rationale === "string" ? o.rationale : undefined
+    };
+}
+/** Compact, metadata-only context for the judge: targeted behaviors + real names. */
+export function buildJudgeContext(graph, groundedTests) {
+    const behaviorIds = new Set(behaviorNodes(graph).map((b) => b.external_id));
+    const targeted = new Set();
+    for (const t of groundedTests)
+        for (const id of t.grounding.entity_ids)
+            if (behaviorIds.has(id))
+                targeted.add(id);
+    const lines = ["TARGET BEHAVIORS:"];
+    for (const id of targeted) {
+        const n = graph.nodes.find((x) => x.external_id === id);
+        if (!n)
+            continue;
+        const ac = Array.isArray(n.properties.acceptance_criteria) ? n.properties.acceptance_criteria : [];
+        lines.push(`- ${n.title || id}${ac.length ? ` (acceptance criteria: ${ac.slice(0, 4).map(String).join("; ")})` : ""}`);
+    }
+    if (targeted.size === 0)
+        lines.push("- (none resolved from grounding)");
+    // The grounded arm's source refs were validated against the local graph —
+    // list them explicitly so the judge can never call them invented. (The global
+    // sample below is 40-of-N: on a big repo it almost never contains the
+    // targeted files, and the old "treat names outside this list as possibly
+    // invented" wording made the judge zero accuracy/domain on that false
+    // premise — "ProfilePopover not present in this repo" on Mattermost.)
+    const groundedRefs = [];
+    for (const t of groundedTests) {
+        for (const r of t.grounding.source_refs || [])
+            if (!groundedRefs.includes(r))
+                groundedRefs.push(r);
+    }
+    if (groundedRefs.length) {
+        lines.push("", "GROUNDED REPO FILES (validated to exist in this repo — never treat these files, or symbols imported from them, as invented):", groundedRefs.slice(0, 12).join(", "));
+    }
+    const realNames = [];
+    for (const n of graph.nodes) {
+        if (realNames.length >= 40)
+            break;
+        if (n.kind === "File")
+            realNames.push(n.external_id.split("/").pop() || n.external_id);
+        else if (n.kind === "CodeSymbol" && n.title)
+            realNames.push(n.title);
+    }
+    lines.push("", "OTHER REAL MODULES/SYMBOLS (a small sample of a much larger repo — a name absent from this sample is NOT necessarily invented; only penalize clearly generic placeholders):", [...new Set(realNames)].join(", ") || "(none extracted)");
+    return lines.join("\n");
+}
+/** Ask the model to score both suites. Returns null on any failure (caller falls back). */
+export async function judgeComparison(provider, contextText, baselineCode, groundedCode) {
+    const user = [
+        "CONTEXT:",
+        contextText,
+        "",
+        "SUITE A — prompt-only baseline:",
+        "```",
+        baselineCode || "(no tests generated)",
+        "```",
+        "",
+        "SUITE B — Local KG (graph-grounded):",
+        "```",
+        groundedCode || "(no tests generated)",
+        "```",
+        "",
+        "Score both suites now. Return ONLY the JSON object."
+    ].join("\n");
+    try {
+        const raw = await provider.complete({ system: JUDGE_SYSTEM, user, temperature: 0 });
+        return parseJudgeResponse(raw);
+    }
+    catch {
+        return null;
+    }
+}