@orangepro/orangepro-mcp 0.1.0

package/dist/local/enrich/markdown.js

@@ -0,0 +1,193 @@
+import { makeEdge, makeNode } from "../graph/factories.js";
+import { hashString } from "../util/hash.js";
+import { slugify } from "../util/ids.js";
+import { redactSecrets } from "../util/redact.js";
+const DETECTOR = "markdown_docs";
+const MAX_REQUIREMENTS = 60;
+/** Words that suggest a heading describes a requirement/feature behavior. */
+const REQUIREMENT_HINTS = [
+    "requirement",
+    "feature",
+    "behavior",
+    "behaviour",
+    "user story",
+    "story",
+    "use case",
+    "scenario",
+    "capability",
+    "flow",
+    "rule",
+    "must",
+    "should",
+    "shall",
+    "support",
+    "allow"
+];
+/** True when a heading's text looks like a requirement/feature anchor. */
+function looksLikeRequirement(text) {
+    const lower = text.toLowerCase();
+    return REQUIREMENT_HINTS.some((hint) => lower.includes(hint));
+}
+/** True when a heading marks an acceptance-criteria section. */
+function isAcceptanceHeading(text) {
+    return text.toLowerCase().includes("acceptance criteria");
+}
+/** Parse an ATX heading line (#, ##, ###). Returns null for non-headings. */
+function parseHeading(line) {
+    const m = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+    if (!m)
+        return null;
+    return { level: m[1].length, text: m[2].trim() };
+}
+/** Parse a bullet/list-item line, returning its trimmed text or null. */
+function parseBullet(line) {
+    const m = /^\s*(?:[-*+]|\d+[.)])\s+(.+?)\s*$/.exec(line);
+    return m ? m[1].trim() : null;
+}
+/**
+ * Deterministic Markdown enrichment.
+ *
+ * Headings that look like requirements become candidate Requirement nodes
+ * (inferred from doc structure). Bullets under an "acceptance criteria" section
+ * become AcceptanceCriterion nodes linked to the nearest preceding requirement.
+ * Bounded to ~60 requirements; all captured text is secret-redacted.
+ */
+export function enrichFromMarkdown(relPath, content) {
+    const nodes = [];
+    const edges = [];
+    const warnings = [];
+    const sourceScopeId = "markdown_docs:" + slugify(relPath);
+    const source = {
+        source_scope_id: sourceScopeId,
+        source_system: "markdown_docs",
+        source_type: "customer_supplied",
+        display_name: relPath,
+        content_hash: hashString(content),
+        metadata: { filename: relPath }
+    };
+    const prov = (line) => ({
+        source_scope_id: sourceScopeId,
+        source_ref: `${relPath}#L${line}`,
+        detector: DETECTOR
+    });
+    const lines = content.split(/\r\n|\r|\n/);
+    const reqSlugs = new Set();
+    let reqCount = 0;
+    let inFence = false;
+    // Tracks the most recent requirement (for AC linkage) and AC-section state.
+    let currentReqExternalId = null;
+    let lastHeading = null;
+    let inAcceptanceSection = false;
+    let acHeadingLevel = 0;
+    const acCounterByReq = new Map();
+    let capped = false;
+    /** Create a candidate Requirement node from a heading, returning its external id. */
+    const createRequirement = (text, level, line) => {
+        if (capped)
+            return null;
+        if (reqCount >= MAX_REQUIREMENTS) {
+            capped = true;
+            warnings.push(`Markdown '${relPath}' requirement cap (${MAX_REQUIREMENTS}) reached; later headings omitted.`);
+            return null;
+        }
+        const clean = redactSecrets(text);
+        let slug = slugify(clean);
+        let suffix = 1;
+        while (reqSlugs.has(slug)) {
+            suffix++;
+            slug = slugify(clean) + "-" + suffix;
+        }
+        reqSlugs.add(slug);
+        const reqExternalId = "REQ-md-" + slug;
+        nodes.push(makeNode({
+            kind: "Requirement",
+            external_id: reqExternalId,
+            title: clean,
+            properties: { description: clean, heading_level: level, inferred_from: "markdown_heading" },
+            evidence_strength: "candidate",
+            review_status: "inferred",
+            confidence: 0.55,
+            provenance: prov(line),
+            content_hash: hashString(clean),
+            behavior_source: "markdown_requirement",
+            denominator_eligible: true,
+            denominator_reason: "Markdown requirement heading — explicit behavior."
+        }));
+        reqCount++;
+        return reqExternalId;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const rawLine = lines[i];
+        const lineNumber = i + 1;
+        // Respect fenced code blocks: never treat their contents as headings/bullets.
+        if (/^\s*(```|~~~)/.test(rawLine)) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
+        const heading = parseHeading(rawLine);
+        if (heading) {
+            if (isAcceptanceHeading(heading.text)) {
+                inAcceptanceSection = true;
+                acHeadingLevel = heading.level;
+                // An explicit Acceptance Criteria section is strong evidence its preceding
+                // heading is a requirement — promote it even if it lacked a hint word.
+                if (!currentReqExternalId && lastHeading) {
+                    currentReqExternalId = createRequirement(lastHeading.text, lastHeading.level, lastHeading.line);
+                }
+                continue;
+            }
+            // A heading at or above the AC section's level closes that section.
+            if (inAcceptanceSection && heading.level <= acHeadingLevel) {
+                inAcceptanceSection = false;
+            }
+            lastHeading = { text: heading.text, level: heading.level, line: lineNumber };
+            if (looksLikeRequirement(heading.text)) {
+                const id = createRequirement(heading.text, heading.level, lineNumber);
+                if (id)
+                    currentReqExternalId = id;
+            }
+            else {
+                // New non-requirement heading starts a fresh section; forget the prior req
+                // so stray bullets don't attach across unrelated sections.
+                currentReqExternalId = null;
+            }
+            continue;
+        }
+        // Bullets inside an acceptance-criteria section → AcceptanceCriterion nodes.
+        if (inAcceptanceSection && currentReqExternalId) {
+            const bullet = parseBullet(rawLine);
+            if (bullet) {
+                const acText = redactSecrets(bullet);
+                const reqId = currentReqExternalId;
+                const next = (acCounterByReq.get(reqId) ?? 0) + 1;
+                acCounterByReq.set(reqId, next);
+                const acExternalId = "AC-md-" + slugify(reqId.replace(/^REQ-md-/, "")) + "-" + String(next).padStart(3, "0");
+                nodes.push(makeNode({
+                    kind: "AcceptanceCriterion",
+                    external_id: acExternalId,
+                    title: acText,
+                    properties: { text: acText, behavior: reqId, inferred_from: "markdown_acceptance_section" },
+                    evidence_strength: "reviewed",
+                    review_status: "local_reviewed",
+                    confidence: 0.6,
+                    provenance: prov(lineNumber),
+                    content_hash: hashString(acText)
+                }));
+                edges.push(makeEdge({
+                    from_external_id: reqId,
+                    to_external_id: acExternalId,
+                    relationship_type: "HAS_ACCEPTANCE_CRITERION",
+                    evidence_strength: "reviewed",
+                    review_status: "local_reviewed",
+                    provenance: prov(lineNumber)
+                }));
+            }
+        }
+    }
+    if (reqCount === 0) {
+        warnings.push(`Markdown '${relPath}' yielded no requirement headings.`);
+    }
+    return { nodes, edges, candidate_edges: [], sources: [source], warnings };
+}

package/dist/local/explain/explain.js

@@ -0,0 +1,91 @@
+import { findNode, generatedTestById } from "../graph/factories.js";
+/**
+ * Weak relationship labels are emitted by the generator in the form
+ * `REL:from->to` (e.g. `MAY_BE_TESTED_BY:REQ-001->test:src/a.test.ts`).
+ * The relationship prefix ends at the first `:`; the remainder is split on the
+ * first `->`. Labels without a `->` separator (e.g. `inferred_anchor:REQ-001`)
+ * are not parseable and yield null.
+ */
+function parseWeakLabel(label) {
+    const colon = label.indexOf(":");
+    if (colon <= 0)
+        return null;
+    const relationship_type = label.slice(0, colon);
+    const rest = label.slice(colon + 1);
+    const arrow = rest.indexOf("->");
+    if (arrow < 0)
+        return null;
+    const from = rest.slice(0, arrow);
+    const to = rest.slice(arrow + 2);
+    if (from.length === 0 || to.length === 0)
+        return null;
+    return { relationship_type, from, to };
+}
+function matchCandidateEdge(graph, parsed) {
+    return graph.candidate_edges.find((e) => e.relationship_type === parsed.relationship_type &&
+        e.from_external_id === parsed.from &&
+        e.to_external_id === parsed.to);
+}
+export function explainTest(graph, generated_test_id) {
+    const test = generatedTestById(graph, generated_test_id);
+    if (!test) {
+        throw new Error(`Generated test ${generated_test_id} not found in the local graph.`);
+    }
+    const grounded_by = test.grounding.entity_ids.map((externalId) => {
+        const node = findNode(graph, externalId);
+        if (!node) {
+            return {
+                external_id: externalId,
+                kind: "unknown",
+                title: externalId,
+                evidence_strength: "unknown"
+            };
+        }
+        const entry = {
+            external_id: node.external_id,
+            kind: node.kind,
+            title: node.title ?? node.external_id,
+            evidence_strength: node.evidence_strength
+        };
+        if (node.provenance?.source_ref) {
+            entry.source_ref = node.provenance.source_ref;
+        }
+        return entry;
+    });
+    const weak_relationships = test.grounding.weak_relationships_used.map((label) => {
+        // The generator emits `inferred_anchor:<id>` for the weak behavior anchor itself.
+        if (label.startsWith("inferred_anchor:")) {
+            const id = label.slice("inferred_anchor:".length);
+            const node = findNode(graph, id);
+            return {
+                from: id,
+                relation: "INFERRED_ANCHOR",
+                to: "(this behavior)",
+                reason: "Behavior anchor inferred from local test names — weak evidence.",
+                confidence: node ? node.confidence : 0
+            };
+        }
+        const parsed = parseWeakLabel(label);
+        if (!parsed) {
+            return { from: label, relation: "RELATES_TO", to: "(unresolved)", reason: label, confidence: 0 };
+        }
+        const edge = matchCandidateEdge(graph, parsed);
+        return {
+            from: parsed.from,
+            relation: parsed.relationship_type,
+            to: parsed.to,
+            reason: edge ? edge.reason : label,
+            confidence: edge ? edge.confidence : 0
+        };
+    });
+    return {
+        generated_test_id: test.id,
+        title: test.title,
+        behavior_tested: test.title,
+        grounded_by,
+        source_refs: test.grounding.source_refs,
+        weak_evidence_used: test.weak_evidence_used,
+        weak_relationships,
+        stale: Boolean(test.stale)
+    };
+}

package/dist/local/exportCli.js

@@ -0,0 +1,26 @@
+import { opExport, opGraphHtml } from "./operations.js";
+/**
+ * Dispatch the `export` command.
+ *
+ * Only `--format graph-html` takes the explorer-only path; the boolean
+ * `--graph-html` flag falls through to a full pack export (JSON + Markdown, and
+ * the explorer too). Keeping this pure makes both modes unit-testable.
+ */
+export function runExportCli(cwd, flags) {
+    if (flags.format === "graph-html") {
+        const g = opGraphHtml(cwd, flags.out ?? "orangepro-graph.html");
+        return { mode: "graph_html", graph_html_path: g.graph_html_path };
+    }
+    const res = opExport(cwd, flags.out ?? "orangepro-evidence-pack.json", {
+        include_generated_bodies: flags.include_generated_bodies ?? false,
+        graph_html: flags.graph_html ?? false
+    });
+    return {
+        mode: "pack",
+        pack_path: res.pack_path,
+        summary_path: res.summary_path,
+        valid: res.validation.valid,
+        errors: res.validation.errors,
+        graph_html_path: res.graph_html_path
+    };
+}

package/dist/local/flows/flowWalker.js

@@ -0,0 +1,215 @@
+import { buildCallsAdjacency } from "../analyze/clustering.js";
+import { LOCAL_GRAPH_SCHEMA_VERSION } from "../graph/ontology.js";
+import { rankRiskGaps } from "../score/risk.js";
+import { stableId } from "../util/ids.js";
+const DEFAULT_MAX_DEPTH = 8;
+const DEFAULT_MAX_FLOWS_PER_ENTRY = 20;
+const DEFAULT_GLOBAL_CAP = 500;
+const HIGH_ROUTE_RE = /payment|refund|checkout|cart|order|auth|login|token|customer|user|tax|fulfillment|ship/i;
+const MUTATION_METHOD_RE = /^(POST|PUT|PATCH|DELETE)\b/i;
+function flowTier(hops) {
+    return hops.some((h) => h.evidence_strength === "framework-derived")
+        ? "framework-derived: reachable"
+        : "hard: reachable";
+}
+export function behaviorEntries(nodes, edges) {
+    const endpointStarts = new Set(edges.filter((e) => e.relationship_type === "IMPLEMENTED_IN").map((e) => e.to_external_id));
+    const incomingEligibleCalls = new Set();
+    for (const [, outgoing] of buildCallsAdjacency(nodes, edges, { denominatorEligibleOnly: true })) {
+        for (const edge of outgoing)
+            incomingEligibleCalls.add(edge.to);
+    }
+    return nodes
+        .filter((n) => n.kind === "CodeSymbol" &&
+        n.denominator_eligible === true &&
+        n.stale !== true &&
+        !endpointStarts.has(n.external_id) &&
+        !incomingEligibleCalls.has(n.external_id))
+        .map((n) => ({
+        external_id: n.external_id,
+        kind: "Behavior",
+        title: n.title,
+        start: n.external_id
+    }));
+}
+export function endpointEntries(nodes, edges) {
+    const nodesById = new Map(nodes.map((n) => [n.external_id, n]));
+    const codeSymbolIds = new Set(nodes.filter((n) => n.kind === "CodeSymbol" && n.stale !== true).map((n) => n.external_id));
+    const entries = [];
+    for (const e of edges) {
+        if (e.relationship_type !== "IMPLEMENTED_IN" || !codeSymbolIds.has(e.to_external_id))
+            continue;
+        const endpoint = nodesById.get(e.from_external_id);
+        if (!endpoint || endpoint.kind !== "Endpoint")
+            continue;
+        entries.push({
+            external_id: endpoint.external_id,
+            kind: "Endpoint",
+            title: endpoint.title,
+            start: e.to_external_id
+        });
+    }
+    return entries.sort((a, b) => a.external_id.localeCompare(b.external_id) || a.start.localeCompare(b.start));
+}
+export function dedupeEntries(entries) {
+    const seen = new Set();
+    const out = [];
+    for (const e of entries) {
+        const key = `${e.kind}|${e.external_id}|${e.start}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(e);
+    }
+    return out.sort((a, b) => a.kind.localeCompare(b.kind) || a.external_id.localeCompare(b.external_id) || a.start.localeCompare(b.start));
+}
+function minimalGraph(input) {
+    return {
+        schema_version: LOCAL_GRAPH_SCHEMA_VERSION,
+        workspace: {
+            name: "flow-walker",
+            root: input.workspaceRoot ?? "",
+            root_hash: "",
+            source_upload_policy: "metadata_only"
+        },
+        created_at: "",
+        updated_at: "",
+        sources: [],
+        nodes: input.nodes,
+        edges: input.edges,
+        candidate_edges: input.candidate_edges ?? [],
+        generation_runs: [],
+        generated_tests: [],
+        manifest: { generated_at: "", git: null, files: {} }
+    };
+}
+function routeFallbackScore(entry) {
+    if (entry.kind !== "Endpoint")
+        return 0;
+    const text = `${entry.title ?? ""} ${entry.external_id}`;
+    let score = 500;
+    if (MUTATION_METHOD_RE.test(text))
+        score += 250;
+    if (HIGH_ROUTE_RE.test(text))
+        score += 250;
+    return score;
+}
+function fallbackScore(entry, adjacency) {
+    const fanOut = adjacency.get(entry.start)?.length ?? 0;
+    return routeFallbackScore(entry) + fanOut * 10;
+}
+export function rankEntries(graph, entries, adjacency) {
+    const riskScores = new Map(rankRiskGaps(minimalGraph(graph), { repoRoot: graph.workspaceRoot, limit: Math.max(graph.nodes.length, entries.length) }).map((gap) => [
+        gap.id,
+        gap.risk_score
+    ]));
+    return [...entries].sort((a, b) => {
+        const aScore = Math.max(riskScores.get(a.start) ?? 0, fallbackScore(a, adjacency));
+        const bScore = Math.max(riskScores.get(b.start) ?? 0, fallbackScore(b, adjacency));
+        return bScore - aScore || a.kind.localeCompare(b.kind) || a.external_id.localeCompare(b.external_id) || a.start.localeCompare(b.start);
+    });
+}
+function prunePrefixSubsumed(flows) {
+    const sorted = [...flows].sort((a, b) => b.path.length - a.path.length || a.id.localeCompare(b.id));
+    const kept = [];
+    for (const flow of sorted) {
+        const subsumed = kept.some((other) => other.entry_point.external_id === flow.entry_point.external_id &&
+            flow.path.length < other.path.length &&
+            flow.path.every((part, idx) => other.path[idx] === part));
+        if (!subsumed)
+            kept.push(flow);
+    }
+    return kept.sort((a, b) => a.entry_point.external_id.localeCompare(b.entry_point.external_id) || a.id.localeCompare(b.id));
+}
+export function enumerateFlows(graph, opts = {}) {
+    const maxDepth = opts.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const maxFlowsPerEntry = opts.maxFlowsPerEntry ?? DEFAULT_MAX_FLOWS_PER_ENTRY;
+    const globalCap = opts.globalCap ?? DEFAULT_GLOBAL_CAP;
+    const adjacency = buildCallsAdjacency(graph.nodes, graph.edges);
+    const entries = rankEntries(graph, dedupeEntries([...endpointEntries(graph.nodes, graph.edges), ...behaviorEntries(graph.nodes, graph.edges)]), adjacency);
+    const flows = [];
+    const dropped = { max_depth: 0, max_flows_per_entry: 0, global_cap: 0 };
+    for (const entry of entries) {
+        if (flows.length >= globalCap) {
+            if ((adjacency.get(entry.start)?.length ?? 0) > 0)
+                dropped.global_cap++;
+            continue;
+        }
+        const entryFlows = [];
+        const seenPath = new Set();
+        const record = (path, hops, truncated) => {
+            if (hops.length === 0)
+                return true;
+            const key = path.join(">");
+            if (seenPath.has(key))
+                return true;
+            if (entryFlows.length >= maxFlowsPerEntry) {
+                dropped.max_flows_per_entry++;
+                return false;
+            }
+            seenPath.add(key);
+            const tier = flowTier(hops);
+            entryFlows.push({
+                id: stableId("flow", `${entry.kind}|${entry.external_id}|${key}|${tier}`),
+                entry_point: { external_id: entry.external_id, kind: entry.kind, title: entry.title },
+                hops,
+                terminal: path[path.length - 1] ?? entry.start,
+                depth: hops.length,
+                flow_tier: tier,
+                ...(truncated ? { truncated: true } : {}),
+                path
+            });
+            return true;
+        };
+        const walk = (current, path, hops, visited) => {
+            const outgoing = adjacency.get(current) ?? [];
+            if (hops.length >= maxDepth) {
+                dropped.max_depth++;
+                return record(path, hops, true);
+            }
+            const nextEdges = outgoing.filter((edge) => !visited.has(edge.to));
+            if (nextEdges.length === 0)
+                return record(path, hops, false);
+            for (const edge of nextEdges) {
+                const nextVisited = new Set(visited);
+                nextVisited.add(edge.to);
+                const nextHops = [
+                    ...hops,
+                    {
+                        from: edge.from,
+                        to: edge.to,
+                        evidence_strength: edge.evidence_strength,
+                        ...(edge.resolution ? { resolution: edge.resolution } : {})
+                    }
+                ];
+                if (!walk(edge.to, [...path, edge.to], nextHops, nextVisited))
+                    return false;
+            }
+            return true;
+        };
+        walk(entry.start, [entry.start], [], new Set([entry.start]));
+        for (const flow of prunePrefixSubsumed(entryFlows)) {
+            if (flows.length >= globalCap) {
+                dropped.global_cap++;
+                continue;
+            }
+            const { path: _path, ...publicFlow } = flow;
+            flows.push(publicFlow);
+        }
+    }
+    const by_tier = {
+        "hard: reachable": 0,
+        "framework-derived: reachable": 0
+    };
+    for (const flow of flows)
+        by_tier[flow.flow_tier]++;
+    return {
+        method: "static_calls_weakest_link",
+        total_flows: flows.length,
+        by_tier,
+        truncated_flows: flows.filter((f) => f.truncated === true).length,
+        dropped,
+        options: { max_depth: maxDepth, max_flows_per_entry: maxFlowsPerEntry, global_cap: globalCap },
+        flows
+    };
+}