@danielblomma/cortex-mcp 2.4.0 → 2.4.1

package/scaffold/mcp/dist/enterprise/privacy/boundary.js

@@ -0,0 +1,184 @@
+const REPO_METADATA = [
+    "repo",
+    "instance_id",
+    "session_id",
+];
+export const OUTBOUND_DATA_BOUNDARY = {
+    version: 3,
+    excludes: [
+        "source_code",
+        "raw_prompts",
+        "raw_queries",
+        "embeddings",
+        "graph_data",
+        "full_file_contents",
+    ],
+    telemetry: {
+        retention_days: 30,
+        payload_type: "counts_and_metadata_only",
+        allowed_fields: [
+            "period_start",
+            "period_end",
+            "total_tool_calls",
+            "successful_tool_calls",
+            "failed_tool_calls",
+            "total_duration_ms",
+            "session_starts",
+            "session_ends",
+            "session_duration_ms_total",
+            "searches",
+            "related_lookups",
+            "caller_lookups",
+            "trace_lookups",
+            "impact_analyses",
+            "rule_lookups",
+            "reloads",
+            "total_results_returned",
+            "estimated_tokens_saved",
+            "estimated_tokens_total",
+            "client_version",
+            "repo",
+            "instance_id",
+            "session_id",
+            "tool_metrics",
+        ],
+    },
+    audit: {
+        required_retention_days: 365,
+        diagnostic_retention_days: 30,
+        redaction: "string values are summarized to counts/lengths before outbound push",
+        metadata_fields: REPO_METADATA,
+    },
+    reviews: {
+        metadata_fields: REPO_METADATA,
+    },
+    violations: {
+        metadata_fields: REPO_METADATA,
+    },
+    workflow: {
+        metadata_fields: REPO_METADATA,
+    },
+};
+const MAX_OBJECT_KEYS = 12;
+const MAX_ARRAY_ITEMS = 12;
+const SENSITIVE_KEY_RE = /^(?:query|prompt|content|code|diff|patch|body|text|embedding|embeddings|graph|raw_query|raw_prompt|raw_code|raw_content)$/i;
+function summarizeString(value) {
+    return {
+        type: "string",
+        length: value.length,
+        redacted: true,
+    };
+}
+function summarizeArray(value, depth) {
+    if (depth >= 2) {
+        return {
+            type: "array",
+            count: value.length,
+            redacted: true,
+        };
+    }
+    return {
+        type: "array",
+        count: value.length,
+        sample: value.slice(0, MAX_ARRAY_ITEMS).map((item) => summarizeValue(item, depth + 1)),
+    };
+}
+function summarizeObject(value, depth) {
+    const entries = Object.entries(value).slice(0, MAX_OBJECT_KEYS);
+    if (depth >= 2) {
+        return {
+            type: "object",
+            keys: entries.map(([key]) => key),
+            key_count: Object.keys(value).length,
+            redacted: true,
+        };
+    }
+    return Object.fromEntries(entries.map(([key, item]) => [
+        key,
+        SENSITIVE_KEY_RE.test(key)
+            ? summarizeSensitiveValue(item)
+            : summarizeValue(item, depth + 1),
+    ]));
+}
+function summarizeSensitiveValue(value) {
+    if (typeof value === "string")
+        return summarizeString(value);
+    if (Array.isArray(value)) {
+        return {
+            type: "array",
+            count: value.length,
+            redacted: true,
+        };
+    }
+    if (value && typeof value === "object") {
+        return {
+            type: "object",
+            key_count: Object.keys(value).length,
+            redacted: true,
+        };
+    }
+    return {
+        type: typeof value,
+        redacted: true,
+    };
+}
+function summarizeValue(value, depth = 0) {
+    if (value === null || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        return summarizeString(value);
+    }
+    if (Array.isArray(value)) {
+        return summarizeArray(value, depth);
+    }
+    if (value && typeof value === "object") {
+        return summarizeObject(value, depth);
+    }
+    return {
+        type: typeof value,
+        redacted: true,
+    };
+}
+export function sanitizeOutboundRecord(record) {
+    if (!record)
+        return {};
+    return summarizeObject(record, 0);
+}
+export function sanitizeAuditEntryForPush(entry) {
+    return {
+        ...entry,
+        input: sanitizeOutboundRecord(entry.input),
+        error: entry.error ? `[redacted:${entry.error.length}]` : undefined,
+        metadata: entry.metadata ? sanitizeOutboundRecord(entry.metadata) : undefined,
+    };
+}
+export function buildTelemetryPushPayload(metrics, context = {}) {
+    return {
+        period_start: metrics.period_start,
+        period_end: metrics.period_end,
+        total_tool_calls: metrics.total_tool_calls,
+        successful_tool_calls: metrics.successful_tool_calls,
+        failed_tool_calls: metrics.failed_tool_calls,
+        total_duration_ms: metrics.total_duration_ms,
+        session_starts: metrics.session_starts,
+        session_ends: metrics.session_ends,
+        session_duration_ms_total: metrics.session_duration_ms_total,
+        searches: metrics.searches,
+        related_lookups: metrics.related_lookups,
+        caller_lookups: metrics.caller_lookups,
+        trace_lookups: metrics.trace_lookups,
+        impact_analyses: metrics.impact_analyses,
+        rule_lookups: metrics.rule_lookups,
+        reloads: metrics.reloads,
+        total_results_returned: metrics.total_results_returned,
+        estimated_tokens_saved: metrics.estimated_tokens_saved,
+        estimated_tokens_total: metrics.estimated_tokens_total,
+        client_version: metrics.client_version,
+        repo: context.repo,
+        instance_id: metrics.instance_id,
+        session_id: context.session_id,
+        push_id: context.push_id,
+        tool_metrics: metrics.tool_metrics,
+    };
+}

package/scaffold/mcp/dist/enterprise/reviews/changed-files.js

@@ -0,0 +1,33 @@
+import { execFileSync } from "node:child_process";
+function gitLines(projectRoot, args) {
+    const output = execFileSync("git", args, {
+        cwd: projectRoot,
+        encoding: "utf8",
+        timeout: 5000,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    return output.split("\n").map((value) => value.trim()).filter(Boolean);
+}
+function trackedChangedFiles(projectRoot) {
+    try {
+        return gitLines(projectRoot, ["diff", "--name-only", "HEAD"]);
+    }
+    catch {
+        // No HEAD yet (repo without commits): every tracked file is new.
+        return [
+            ...gitLines(projectRoot, ["diff", "--name-only"]),
+            ...gitLines(projectRoot, ["ls-files"]),
+        ];
+    }
+}
+export function resolveChangedReviewFiles(projectRoot) {
+    try {
+        gitLines(projectRoot, ["rev-parse", "--is-inside-work-tree"]);
+        const tracked = trackedChangedFiles(projectRoot);
+        const untracked = gitLines(projectRoot, ["ls-files", "--others", "--exclude-standard"]);
+        return [...new Set([...tracked, ...untracked])].sort();
+    }
+    catch {
+        return null;
+    }
+}

package/scaffold/mcp/dist/enterprise/reviews/pattern-context.js

@@ -0,0 +1,202 @@
+import { loadContextData } from "../../graph.js";
+import { normalizeRepoPath, runLocalPatternEvidence } from "../../patternEvidence.js";
+import { compareText } from "../../searchResults.js";
+// Loads context data lazily on first use and shares it across all targets in
+// one review, instead of re-reading the index from disk per target. Load
+// failures surface per target, matching the per-file error handling below.
+export function createLocalPatternRunner(loadData = loadContextData) {
+    let shared;
+    return async (params) => {
+        shared ??= loadData();
+        return runLocalPatternEvidence(params, { data: await shared });
+    };
+}
+export const PATTERN_REVIEW_QUESTION = "Does this change follow the established pattern for this kind of problem in this repository, or does it introduce a second way to solve something that already has a local convention?";
+const PATTERN_EVIDENCE_ORDER = ["same_file", "same_module", "same_feature_area", "repo_wide"];
+// Canonicalizes like the pattern evidence engine, then rejects paths that
+// must never appear in review citations (absolute, drive-letter, or
+// parent-escaping paths).
+function normalizeReviewPath(value) {
+    const normalized = normalizeRepoPath(value);
+    if (!normalized ||
+        normalized.startsWith("/") ||
+        /^[A-Za-z]:\//.test(normalized) ||
+        normalized.split("/").includes("..")) {
+        return null;
+    }
+    return normalized;
+}
+function safeIdentifier(value) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 1000)
+        return null;
+    if (/(?:^|:)\/|[A-Za-z]:[\\/]|(?:^|[:/])\.\.(?:[:/]|$)/u.test(value))
+        return null;
+    return value;
+}
+function emptyTiers() {
+    return PATTERN_EVIDENCE_ORDER.map((name) => ({ name, evidence: [] }));
+}
+function sanitizeEvidenceTiers(value) {
+    const inputTiers = Array.isArray(value) ? value : [];
+    let dropped = 0;
+    const tiers = PATTERN_EVIDENCE_ORDER.map((name) => {
+        const source = inputTiers.find((candidate) => candidate && typeof candidate === "object" && candidate.name === name);
+        const rawEvidence = Array.isArray(source?.evidence) ? source.evidence : [];
+        const evidence = [];
+        for (const candidate of rawEvidence) {
+            if (!candidate || typeof candidate !== "object") {
+                dropped += 1;
+                continue;
+            }
+            const row = candidate;
+            const citationPath = typeof row.path === "string" ? normalizeReviewPath(row.path) : null;
+            const id = safeIdentifier(row.id);
+            if (!citationPath || !id) {
+                dropped += 1;
+                continue;
+            }
+            evidence.push({
+                id,
+                entity_type: typeof row.entity_type === "string" ? row.entity_type.slice(0, 100) : "",
+                kind: typeof row.kind === "string" ? row.kind.slice(0, 100) : "",
+                title: typeof row.title === "string" ? row.title.slice(0, 500) : id,
+                path: citationPath,
+                start_line: Number.isInteger(row.start_line) ? row.start_line : null,
+                end_line: Number.isInteger(row.end_line) ? row.end_line : null,
+                excerpt: typeof row.excerpt === "string" ? row.excerpt.slice(0, 1000) : "",
+                score: typeof row.score === "number" && Number.isFinite(row.score) ? row.score : null,
+                matched_rules: Array.isArray(row.matched_rules)
+                    ? row.matched_rules.filter((item) => typeof item === "string").slice(0, 50)
+                    : [],
+            });
+        }
+        return { name, evidence };
+    });
+    return { tiers, dropped };
+}
+function emptyTarget(file, status, query) {
+    return {
+        path: file,
+        status,
+        review_question: PATTERN_REVIEW_QUESTION,
+        query: query ?? null,
+        query_source: query ? "explicit" : null,
+        local_pattern_found: false,
+        fallback_used: false,
+        evidence_order: [...PATTERN_EVIDENCE_ORDER],
+        tiers: emptyTiers(),
+        warning: null,
+        message: status === "not_indexed"
+            ? "Target is not present as a file-backed entity in the current Cortex index. Run cortex update before reviewing it."
+            : "Pattern evidence could not be produced for this target.",
+        citations_dropped: 0,
+    };
+}
+function disabledPatternReview(requested, limit, topK) {
+    return {
+        enabled: false,
+        non_blocking: true,
+        affects_policy_summary: false,
+        review_question: PATTERN_REVIEW_QUESTION,
+        limit,
+        top_k_per_tier: topK,
+        targets: [],
+        summary: {
+            requested,
+            eligible: 0,
+            analyzed: 0,
+            local_evidence: 0,
+            repo_fallback: 0,
+            no_evidence: 0,
+            not_indexed: 0,
+            errors: 0,
+            omitted: 0,
+            invalid_paths: 0,
+        },
+    };
+}
+export async function buildPatternReviewContext(input) {
+    if (!input.enabled) {
+        return disabledPatternReview(input.files.length, input.limit, input.topK);
+    }
+    const normalized = input.files.map(normalizeReviewPath);
+    const invalidPaths = normalized.filter((value) => value === null).length;
+    const eligible = [...new Set(normalized.filter((value) => value !== null))]
+        .sort(compareText);
+    const selected = eligible.slice(0, input.limit);
+    const runner = input.runner ?? createLocalPatternRunner();
+    const targets = [];
+    const counts = {
+        local_evidence: 0,
+        repo_fallback: 0,
+        no_evidence: 0,
+        not_indexed: 0,
+        errors: 0,
+    };
+    for (const file of selected) {
+        try {
+            const evidence = await runner({
+                target: file,
+                query: input.query,
+                top_k: input.topK,
+                include_deprecated: false,
+            });
+            const sanitized = sanitizeEvidenceTiers(evidence.tiers);
+            const localPatternFound = sanitized.tiers.slice(0, 3).some((tier) => Array.isArray(tier.evidence) && tier.evidence.length > 0);
+            const repoEvidence = sanitized.tiers[3].evidence;
+            const fallbackUsed = !localPatternFound && Array.isArray(repoEvidence) && repoEvidence.length > 0;
+            const status = localPatternFound
+                ? "local_evidence"
+                : fallbackUsed
+                    ? "repo_fallback"
+                    : "no_evidence";
+            counts[status] += 1;
+            const warning = status === "local_evidence"
+                ? typeof evidence.warning === "string" ? "Pattern evidence completed with local runtime warnings." : null
+                : status === "repo_fallback"
+                    ? "No applicable local pattern evidence was found; repository-wide fallback evidence is provided."
+                    : "No applicable local pattern evidence was found.";
+            targets.push({
+                path: file,
+                status,
+                review_question: PATTERN_REVIEW_QUESTION,
+                query: typeof evidence.query === "string" ? evidence.query.slice(0, 1000) : input.query ?? null,
+                query_source: evidence.query_source === "explicit" || evidence.query_source === "derived_from_target"
+                    ? evidence.query_source
+                    : input.query ? "explicit" : null,
+                local_pattern_found: localPatternFound,
+                fallback_used: fallbackUsed,
+                evidence_order: [...PATTERN_EVIDENCE_ORDER],
+                tiers: sanitized.tiers,
+                warning,
+                message: null,
+                citations_dropped: sanitized.dropped,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const notIndexed = /not found in indexed context|not file-backed/u.test(message);
+            const status = notIndexed ? "not_indexed" : "error";
+            counts[notIndexed ? "not_indexed" : "errors"] += 1;
+            targets.push(emptyTarget(file, status, input.query));
+        }
+    }
+    return {
+        enabled: true,
+        non_blocking: true,
+        affects_policy_summary: false,
+        review_question: PATTERN_REVIEW_QUESTION,
+        query: input.query ?? null,
+        limit: input.limit,
+        top_k_per_tier: input.topK,
+        targets,
+        summary: {
+            requested: input.files.length,
+            eligible: eligible.length,
+            analyzed: selected.length,
+            ...counts,
+            omitted: Math.max(0, eligible.length - selected.length),
+            invalid_paths: invalidPaths,
+        },
+    };
+}

package/scaffold/mcp/dist/enterprise/reviews/policy-selection.js

@@ -0,0 +1,46 @@
+import { getGenericEvaluator, getValidator, } from "../../core/validators/engine.js";
+export const DEFERRED_CODE_REVIEW_REASON = "Current context.review invocation is the review being recorded; validate this policy from workflow state on the next run.";
+export function partitionReviewPolicies(policies) {
+    const enforced = [];
+    const skipped = [];
+    for (const policy of policies) {
+        if (!policy.enforce)
+            continue;
+        if (policy.id === "require-code-review") {
+            skipped.push({
+                policy_id: policy.id,
+                kind: policy.kind ?? null,
+                type: policy.type ?? null,
+                reason: DEFERRED_CODE_REVIEW_REASON,
+            });
+            continue;
+        }
+        if (policy.type) {
+            if (!getGenericEvaluator(policy.type)) {
+                skipped.push({
+                    policy_id: policy.id,
+                    kind: policy.kind ?? null,
+                    type: policy.type,
+                    reason: `No evaluator registered for type "${policy.type}"`,
+                });
+                continue;
+            }
+        }
+        else if (!getValidator(policy.id)) {
+            skipped.push({
+                policy_id: policy.id,
+                kind: policy.kind ?? null,
+                type: null,
+                reason: "No executable validator registered for this policy",
+            });
+            continue;
+        }
+        enforced.push({
+            id: policy.id,
+            type: policy.type ?? null,
+            config: policy.config ?? null,
+            severity: policy.severity ?? "block",
+        });
+    }
+    return { enforced, skipped };
+}

package/scaffold/mcp/dist/enterprise/reviews/push.js

@@ -0,0 +1,102 @@
+import { recordReviewDeliveryStatus } from "./trust-state.js";
+import { isAllowedEnterpriseEndpoint } from "../../core/secure-endpoint.js";
+const pending = [];
+let activeContext = {};
+export function setReviewPushContext(context) {
+    activeContext = { ...context };
+}
+export function getReviewPushContext() {
+    return { ...activeContext };
+}
+export function queueReviewResult(item) {
+    pending.push(item);
+}
+export function pendingCount() {
+    return pending.length;
+}
+export async function pushReviewResults(baseUrl, apiKey) {
+    if (pending.length === 0) {
+        return { success: true, count: 0, attempted: false };
+    }
+    if (!isAllowedEnterpriseEndpoint(baseUrl)) {
+        return {
+            success: false,
+            count: 0,
+            error: "insecure or invalid enterprise endpoint",
+            attempted: false,
+        };
+    }
+    const reviewsUrl = `${baseUrl.replace(/\/$/, "")}/api/v1/reviews/push`;
+    const batch = pending.splice(0, 100);
+    const attemptedAt = new Date().toISOString();
+    if (activeContext.context_dir) {
+        recordReviewDeliveryStatus(activeContext.context_dir, "pushed", {
+            reviewCount: batch.length,
+            attemptedAt,
+        });
+    }
+    try {
+        const response = await fetch(reviewsUrl, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+            body: JSON.stringify({
+                repo: activeContext.repo,
+                instance_id: activeContext.instance_id,
+                session_id: activeContext.session_id,
+                reviews: batch,
+            }),
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!response.ok) {
+            pending.unshift(...batch);
+            if (activeContext.context_dir) {
+                recordReviewDeliveryStatus(activeContext.context_dir, "failed", {
+                    reviewCount: batch.length,
+                    attemptedAt,
+                    error: `HTTP ${response.status}`,
+                });
+            }
+            return {
+                success: false,
+                count: 0,
+                error: `HTTP ${response.status}`,
+                attempted: true,
+                delivery_status: "failed",
+            };
+        }
+        if (activeContext.context_dir) {
+            recordReviewDeliveryStatus(activeContext.context_dir, "accepted", {
+                reviewCount: batch.length,
+                attemptedAt,
+            });
+        }
+        return {
+            success: true,
+            count: batch.length,
+            attempted: true,
+            delivery_status: "accepted",
+        };
+    }
+    catch (err) {
+        pending.unshift(...batch);
+        const error = err instanceof Error ? err.message : "unknown error";
+        if (activeContext.context_dir) {
+            recordReviewDeliveryStatus(activeContext.context_dir, "failed", {
+                reviewCount: batch.length,
+                attemptedAt,
+                error,
+            });
+        }
+        return {
+            success: false,
+            count: 0,
+            error,
+            attempted: true,
+            delivery_status: "failed",
+        };
+    }
+}