flowseeker 0.1.8 → 0.1.9

package/dist/framework/laravel.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.laravelSlotMapping = void 0;
+exports.detectLaravelFramework = detectLaravelFramework;
+exports.classifyLaravelTask = classifyLaravelTask;
+exports.laravelCategoryRequiredSlots = laravelCategoryRequiredSlots;
+exports.laravelMissingLinkHints = laravelMissingLinkHints;
+exports.applyLaravelTemplate = applyLaravelTemplate;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const laravelSignals = [
+    { path: "artisan", weight: 8, label: "artisan" },
+    { path: "routes/web.php", weight: 6, label: "routes/web.php" },
+    { path: "routes/api.php", weight: 5, label: "routes/api.php" },
+    { path: "app/Http/Controllers", weight: 5, label: "app/Http/Controllers" },
+    { path: "app/Models", weight: 4, label: "app/Models" },
+    { path: "resources/views", weight: 4, label: "resources/views" },
+    { path: "config/app.php", weight: 3, label: "config/app.php" },
+    { path: "bootstrap/app.php", weight: 3, label: "bootstrap/app.php" },
+    { path: "app/Providers", weight: 2, label: "app/Providers" },
+    { path: "app/Http/Middleware", weight: 2, label: "app/Http/Middleware" },
+    { path: "database/migrations", weight: 2, label: "database/migrations" },
+    { path: "app/Console", weight: 2, label: "app/Console" },
+    { path: "vite.config.js", weight: 1, label: "vite.config.js" },
+];
+const minScoreForLaravel = 12;
+async function detectLaravelFramework(rootPath) {
+    const signals = [];
+    let score = 0;
+    for (const signal of laravelSignals) {
+        try {
+            await fs.access(path.join(rootPath, signal.path));
+            score += signal.weight;
+            signals.push(signal.label);
+        }
+        catch {
+            // path doesn't exist
+        }
+    }
+    // Check composer.json for laravel/framework dependency
+    try {
+        const composerRaw = await fs.readFile(path.join(rootPath, "composer.json"), "utf8");
+        const composer = JSON.parse(composerRaw);
+        const deps = { ...(composer.require ?? {}), ...(composer["require-dev"] ?? {}) };
+        if (deps["laravel/framework"]) {
+            score += 10;
+            signals.push("composer:laravel/framework");
+        }
+        const illuminateDeps = Object.keys(deps).filter((k) => k.startsWith("illuminate/"));
+        if (illuminateDeps.length > 0) {
+            score += Math.min(5, illuminateDeps.length);
+            signals.push(`composer:illuminate(${illuminateDeps.length})`);
+        }
+    }
+    catch {
+        // no composer.json
+    }
+    const confidence = Math.min(1, score / 25);
+    return {
+        isLaravel: score >= minScoreForLaravel,
+        confidence,
+        signals,
+    };
+}
+// ── Laravel slot → directory mapping ──────────────────────────────────────────
+exports.laravelSlotMapping = {
+    entry: ["routes/*.php"],
+    handler: ["app/Http/Controllers/**"],
+    domain: ["app/Services/**", "app/Actions/**", "app/Exports/**", "app/Imports/**"],
+    data: ["app/Models/**", "app/Repositories/**", "database/migrations/**"],
+    validation: ["app/Http/Requests/**"],
+    permission: ["app/Policies/**", "app/Http/Middleware/**"],
+    config: ["config/**", ".env", ".env.example"],
+    side_effect: ["app/Jobs/**", "app/Events/**", "app/Listeners/**", "app/Mail/**", "app/Notifications/**"],
+    ui: ["resources/views/**"],
+    tests: ["tests/**"],
+    docs: [],
+    unknown: [],
+};
+function classifyLaravelTask(normalizedTask) {
+    const t = normalizedTask.toLowerCase();
+    if (/\bimport\b/.test(t) || /\bupload\b/.test(t))
+        return "import";
+    if (/\b(export|download|excel|csv|report|pdf)\b/.test(t))
+        return "export_report";
+    if (/\b(auth|login|logout|register|permission|role|policy|guard)\b/.test(t))
+        return "auth_permission";
+    if (/\b(payment|invoice|billing|checkout|refund|gateway)\b/.test(t))
+        return "payment_invoice";
+    if (/\b(email|notification|notify|mail|job|event|listener|dispatch)\b/.test(t))
+        return "notification_email";
+    if (/\b(view|display|page|blade|layout|render|frontend|ui|modal)\b/.test(t))
+        return "view_display";
+    return "generic";
+}
+function laravelCategoryRequiredSlots(category) {
+    const mapping = {
+        export_report: ["entry", "handler", "domain", "data", "side_effect", "tests"],
+        import: ["entry", "handler", "domain", "validation", "data", "tests"],
+        auth_permission: ["entry", "handler", "permission", "domain", "data", "tests"],
+        payment_invoice: ["entry", "handler", "domain", "data", "side_effect", "tests"],
+        notification_email: ["entry", "handler", "side_effect", "data", "tests"],
+        view_display: ["entry", "handler", "ui", "data", "tests"],
+        generic: ["entry", "handler", "domain", "data", "tests"],
+    };
+    return mapping[category] ?? mapping.generic;
+}
+// ── Missing-link hints ────────────────────────────────────────────────────────
+function laravelMissingLinkHints(missingSlots) {
+    const hints = [];
+    for (const slot of missingSlots) {
+        const dirs = exports.laravelSlotMapping[slot];
+        if (dirs && dirs.length > 0) {
+            hints.push(`missing ${slot}: check ${dirs.join(", ")}`);
+        }
+    }
+    return hints;
+}
+async function applyLaravelTemplate(rootPath, normalizedTask, existingRequiredSlots) {
+    const detection = await detectLaravelFramework(rootPath);
+    if (!detection.isLaravel) {
+        return {
+            detected: false,
+            confidence: detection.confidence,
+            category: "generic",
+            suggestedRequiredSlots: [],
+            missingLinkHints: [],
+        };
+    }
+    const category = classifyLaravelTask(normalizedTask);
+    const templateSlots = laravelCategoryRequiredSlots(category);
+    const existing = new Set(existingRequiredSlots);
+    const suggested = templateSlots.filter((s) => !existing.has(s));
+    const missing = templateSlots.filter((s) => !existing.has(s));
+    const hints = laravelMissingLinkHints(missing);
+    return {
+        detected: true,
+        confidence: detection.confidence,
+        category,
+        suggestedRequiredSlots: suggested,
+        missingLinkHints: hints,
+    };
+}
+//# sourceMappingURL=laravel.js.map

package/dist/index/semanticChunkIndex.js

@@ -0,0 +1,388 @@
+"use strict";
+// Semantic Chunk Index — Phase 18A, report-only.
+// Provides typed diagnostics and a fake/test provider path.
+// Does not change default deterministic retrieval ranking.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSemanticChunkDiagnostic = buildSemanticChunkDiagnostic;
+exports.computeSemanticChunkDiagnostics = computeSemanticChunkDiagnostics;
+exports.generateSlotQueries = generateSlotQueries;
+exports.computeSlotHits = computeSlotHits;
+exports.buildContributionReport = buildContributionReport;
+exports.buildHybridPromotionReport = buildHybridPromotionReport;
+const crypto = __importStar(require("crypto"));
+// ── Safe hashing ──────────────────────────────────────────────────────
+function hashChunk(text) {
+    return crypto.createHash("sha256").update(text, "utf8").digest("hex").substring(0, 16);
+}
+// ── Cache key ──────────────────────────────────────────────────────────
+function cacheKey(base, provider, model, dims, chunkId, chunkHash) {
+    return [base, provider, model, String(dims), chunkId, chunkHash, "v18a-1"].join(":");
+}
+// ── Diagnostics builder ────────────────────────────────────────────────
+function buildSemanticChunkDiagnostic(config, results) {
+    const enabled = config?.index?.semanticEnabled === true;
+    const provider = config?.index?.semanticProvider || "";
+    const model = config?.index?.semanticModel || "";
+    let readiness = "disabled";
+    if (enabled) {
+        if (!provider || !model)
+            readiness = "unavailable";
+        else if (!results.providerReady)
+            readiness = "unavailable";
+        else
+            readiness = "configured";
+    }
+    return {
+        enabled,
+        provider,
+        model,
+        readiness,
+        chunksConsidered: results.chunksConsidered,
+        cacheHits: results.cacheHits,
+        cacheMisses: results.cacheMisses,
+        candidatesFound: results.candidatesFound,
+        candidatesAccepted: results.candidatesAccepted,
+        candidatesRejected: results.candidatesRejected,
+        topKContribution: results.topK,
+        reportOnly: true,
+        warnings: results.providerError ? [results.providerError] : [],
+        slotQueries: results.slotQueries || [],
+        slotHits: results.slotHits || [],
+        contributionReport: results.contributionReport,
+        hybridPromotionReport: results.hybridPromotionReport,
+    };
+}
+// ── Entry point: compute semantic chunk diagnostics (report-only) ────
+async function computeSemanticChunkDiagnostics(workspaceRoot, config, provider, taskText, chunkTexts) {
+    // Early return: semantic disabled must never call provider
+    if (!config?.index?.semanticEnabled) {
+        return {
+            diagnostic: buildSemanticChunkDiagnostic(config, {
+                chunksConsidered: 0, cacheHits: 0, cacheMisses: 0,
+                candidatesFound: 0, candidatesAccepted: 0, candidatesRejected: 0,
+                topK: 0, providerReady: false,
+                contributionReport: buildContributionReport(false, false, 0, 0),
+                hybridPromotionReport: buildHybridPromotionReport(false, false, [], [], []),
+            }),
+            hits: [],
+        };
+    }
+    const chunksConsidered = chunkTexts.length;
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    let candidatesFound = 0;
+    const hits = [];
+    if (!provider) {
+        return {
+            diagnostic: buildSemanticChunkDiagnostic(config, {
+                chunksConsidered, cacheHits, cacheMisses, candidatesFound,
+                candidatesAccepted: 0, candidatesRejected: 0, topK: 0,
+                providerReady: false, providerError: "No embedding provider configured",
+                contributionReport: buildContributionReport(true, false, 0, 0),
+                hybridPromotionReport: buildHybridPromotionReport(true, false, [], [], []),
+            }),
+            hits: [],
+        };
+    }
+    // Compute embeddings (fake or real)
+    try {
+        const texts = chunkTexts.map(c => c.text);
+        const taskEmbedding = await provider.embedTexts([taskText]);
+        const chunkEmbeddings = await provider.embedTexts(texts);
+        // Cosine similarity
+        for (let i = 0; i < chunkEmbeddings.length; i++) {
+            const sim = cosineSimilarity(taskEmbedding[0], chunkEmbeddings[i]);
+            if (sim > 0.5) {
+                candidatesFound++;
+                hits.push({
+                    filePath: chunkTexts[i].filePath,
+                    chunkId: chunkTexts[i].id,
+                    startLine: chunkTexts[i].startLine,
+                    endLine: chunkTexts[i].endLine,
+                    kind: chunkTexts[i].kind,
+                    slot: chunkTexts[i].slot,
+                    similarity: parseFloat(sim.toFixed(4)),
+                    rank: i + 1,
+                    reason: `semantic similarity ${sim.toFixed(3)}`,
+                    contentPreview: chunkTexts[i].text.substring(0, 100),
+                });
+            }
+        }
+        cacheMisses = chunksConsidered;
+    }
+    catch (e) {
+        return {
+            diagnostic: buildSemanticChunkDiagnostic(config, {
+                chunksConsidered, cacheHits, cacheMisses, candidatesFound,
+                candidatesAccepted: 0, candidatesRejected: 0, topK: 0,
+                providerReady: false, providerError: e?.message || String(e),
+                contributionReport: buildContributionReport(true, false, 0, 0),
+                hybridPromotionReport: buildHybridPromotionReport(true, false, [], [], []),
+            }),
+            hits: [],
+        };
+    }
+    const diagnostic = buildSemanticChunkDiagnostic(config, {
+        chunksConsidered, cacheHits: 0, cacheMisses: chunksConsidered, candidatesFound,
+        candidatesAccepted: 0, candidatesRejected: 0, topK: 0,
+        providerReady: true,
+        contributionReport: buildContributionReport(true, true, candidatesFound, 0),
+        hybridPromotionReport: buildHybridPromotionReport(true, true, hits, [], []),
+    });
+    return { diagnostic, hits };
+}
+// ── Slot query generation ────────────────────────────────────────────
+var slotSearchTerms = {
+    entry: ["route", "routes", "router", "endpoint", "api", "page", "screen", "loader", "action"],
+    handler: ["controller", "handler", "action", "resolver", "listener", "job", "worker", "consumer", "command", "commands"],
+    domain: ["service", "usecase", "use_case", "repository", "manager", "processor", "model", "entity", "store", "stores", "hook", "hooks"],
+    data: ["model", "models", "schema", "migration", "database", "table", "query", "entity", "orm", "prisma"],
+    validation: ["request", "validator", "validation", "rule", "rules", "dto", "formrequest", "schema"],
+    permission: ["policy", "permission", "role", "guard", "middleware", "authorize", "auth", "acl"],
+    config: ["config", "env", "setting", "settings", "feature", "flag", "yaml", "json"],
+    side_effect: ["event", "listener", "job", "queue", "mail", "email", "notification", "webhook", "cache", "dispatch"],
+    ui: ["component", "page", "view", "screen", "template", "form", "button", "modal", "layout", "responsive", "grid", "drawer", "sidebar", "toast", "chart"],
+    tests: ["test", "tests", "spec", "expect", "assert", "fixture", "fixtures"],
+    docs: ["readme", "docs", "documentation", "markdown", "guide"],
+    unknown: []
+};
+function generateSlotQueries(taskText, requiredSlots, optionalSlots) {
+    var queries = [];
+    var seen = {};
+    function canonicalSlot(slot) {
+        if (slot === "tests")
+            return "test";
+        return slot;
+    }
+    function add(slot, required) {
+        var canon = canonicalSlot(slot);
+        if (seen[canon])
+            return;
+        seen[canon] = true;
+        // Lookup terms by original slot name
+        var terms = slotSearchTerms[slot] || [];
+        if (terms.length === 0)
+            return;
+        queries.push({
+            slot: canon,
+            query: taskText + " " + terms.join(" "),
+            source: "task_blueprint",
+            required: required,
+            weight: required ? 1.0 : 0.5,
+            reasons: [(required ? "required" : "optional") + " slot: " + canon]
+        });
+    }
+    for (var r = 0; r < requiredSlots.length; r++)
+        add(requiredSlots[r], true);
+    for (var o = 0; o < optionalSlots.length; o++)
+        add(optionalSlots[o], false);
+    return queries;
+}
+async function computeSlotHits(provider, slotQueries, chunkTexts) {
+    if (!provider || slotQueries.length === 0)
+        return [];
+    try {
+        var slotHits = [];
+        for (var sq = 0; sq < slotQueries.length; sq++) {
+            var sqObj = slotQueries[sq];
+            var qEmb = await provider.embedTexts([sqObj.query]);
+            var chunkEmbs = await provider.embedTexts(chunkTexts.map(function (c) { return c.text; }));
+            var slotCandidates = [];
+            for (var ci = 0; ci < chunkEmbs.length; ci++) {
+                var sim = cosineSimilarity(qEmb[0], chunkEmbs[ci]);
+                if (sim > 0.4) {
+                    slotCandidates.push({
+                        filePath: chunkTexts[ci].filePath, chunkId: chunkTexts[ci].id,
+                        startLine: chunkTexts[ci].startLine, endLine: chunkTexts[ci].endLine,
+                        kind: chunkTexts[ci].kind, slot: chunkTexts[ci].slot,
+                        similarity: parseFloat(sim.toFixed(4)), rank: ci + 1,
+                        reason: "slot " + sqObj.slot + " sim " + sim.toFixed(3),
+                        contentPreview: chunkTexts[ci].text.substring(0, 80),
+                    });
+                }
+            }
+            var hitCount = slotCandidates.length;
+            var recoveryStatus = hitCount >= 3 ? "recovered" : hitCount > 0 ? "not_recovered" : "not_evaluated";
+            slotHits.push({
+                slot: sqObj.slot, query: sqObj.query.substring(0, 80),
+                hits: hitCount, hitCount: hitCount,
+                recoveryStatus: recoveryStatus,
+                missingBeforeSemantic: hitCount === 0,
+                recoveredBySemantic: hitCount >= 3,
+                topCandidates: slotCandidates.slice(0, 3)
+            });
+        }
+        return slotHits;
+    }
+    catch (e) {
+        return [];
+    }
+}
+// ── Contribution report builder ──────────────────────────────────────
+function buildContributionReport(semanticEnabled, providerReady, hitsFound, deterministicTopCount) {
+    if (!semanticEnabled) {
+        return {
+            addedCandidates: 0, acceptedCandidates: 0, rejectedCandidates: 0,
+            semanticOnlyCandidates: 0, deterministicOverlap: 0, topKDelta: 0,
+            noOp: true, regressionRisk: "none",
+            reasons: ["semantic disabled"],
+            status: "disabled",
+        };
+    }
+    if (!providerReady) {
+        return {
+            addedCandidates: 0, acceptedCandidates: 0, rejectedCandidates: 0,
+            semanticOnlyCandidates: 0, deterministicOverlap: 0, topKDelta: 0,
+            noOp: true, regressionRisk: "none",
+            reasons: ["provider unavailable"],
+            status: "unavailable",
+        };
+    }
+    if (hitsFound === 0) {
+        return {
+            addedCandidates: 0, acceptedCandidates: 0, rejectedCandidates: 0,
+            semanticOnlyCandidates: 0, deterministicOverlap: 0, topKDelta: 0,
+            noOp: true, regressionRisk: "none",
+            reasons: ["no semantic hits found"],
+            status: "no_hits",
+        };
+    }
+    return {
+        addedCandidates: hitsFound,
+        acceptedCandidates: hitsFound,
+        rejectedCandidates: 0,
+        semanticOnlyCandidates: hitsFound,
+        deterministicOverlap: 0,
+        topKDelta: hitsFound,
+        noOp: false,
+        regressionRisk: hitsFound > 5 ? "low" : "none",
+        reasons: ["report-only: contribution measured, no ranking change"],
+        status: "report_only",
+    };
+}
+// ── Hybrid-safe promotion (diagnostic only) ─────────────────────────
+var ALLOWED_GUARDS = ["deterministic_anchor_overlap", "missing_slot_recovery", "strong_path_evidence"];
+var BLOCKING_GUARDS = ["avoid_or_noise_block", "semantic_unavailable_block", "report_only_guard"];
+function buildHybridPromotionReport(semanticEnabled, providerReady, hits, deterministicAnchors, missingSlots) {
+    var guardExplanations = {};
+    var promoted = [];
+    var blocked = [];
+    if (!semanticEnabled || !providerReady) {
+        guardExplanations["semantic_unavailable_block"] = "semantic is disabled or provider unavailable";
+        guardExplanations["report_only_guard"] = "promotion is report-only in Sprint 18D";
+        var guardResults = [];
+        BLOCKING_GUARDS.forEach(function (g) { guardResults.push({ guard: g, passed: false, reason: g }); });
+        ALLOWED_GUARDS.forEach(function (g) { guardResults.push({ guard: g, passed: false, reason: "semantic unavailable" }); });
+        return {
+            totalDiscovered: 0, promotedCandidates: 0, blockedCandidates: 0,
+            guardExplanations, guardResults, promoted, blocked,
+            promotionReasons: [], blockReasons: ["semantic_unavailable_block"],
+            mode: "disabled", safeForDefaultRanking: false,
+        };
+    }
+    var anchorSet = {};
+    for (var a = 0; a < deterministicAnchors.length; a++)
+        anchorSet[deterministicAnchors[a]] = true;
+    var slotSet = {};
+    for (var ms = 0; ms < missingSlots.length; ms++)
+        slotSet[missingSlots[ms]] = true;
+    for (var hi = 0; hi < hits.length; hi++) {
+        var hit = hits[hi];
+        var canPromote = false;
+        var reason = "";
+        // Check deterministic anchor overlap
+        if (anchorSet[hit.filePath]) {
+            canPromote = true;
+            reason = "deterministic_anchor_overlap";
+        }
+        // Check missing slot recovery
+        else if (slotSet[hit.slot]) {
+            canPromote = true;
+            reason = "missing_slot_recovery";
+        }
+        // Check strong path evidence
+        else if (hit.similarity > 0.7) {
+            canPromote = true;
+            reason = "strong_path_evidence";
+        }
+        // Block with explanation
+        else {
+            reason = "avoid_or_noise_block";
+        }
+        if (canPromote) {
+            promoted.push({ filePath: hit.filePath, reason: reason });
+        }
+        else {
+            blocked.push({ filePath: hit.filePath, reason: reason });
+        }
+    }
+    guardExplanations["report_only_guard"] = "promotion is report-only in Sprint 18D; ranking unchanged";
+    ALLOWED_GUARDS.forEach(function (g) { guardExplanations[g] = "allowed: " + g; });
+    BLOCKING_GUARDS.forEach(function (g) { guardExplanations[g] = g; });
+    var guardResults = [];
+    BLOCKING_GUARDS.forEach(function (g) { guardResults.push({ guard: g, passed: false, reason: g }); });
+    ALLOWED_GUARDS.forEach(function (g) {
+        var p = promoted.some(function (p) { return p.reason === g; });
+        guardResults.push({ guard: g, passed: p, reason: p ? g + " matched " + promoted.filter(function (x) { return x.reason === g; }).length + " candidate(s)" : "no " + g + " candidates found" });
+    });
+    var promotionReasons = promoted.map(function (p) { return p.reason; }).filter(function (r, i, arr) { return arr.indexOf(r) === i; });
+    var blockReasons = blocked.map(function (b) { return b.reason; }).filter(function (r, i, arr) { return arr.indexOf(r) === i; });
+    return {
+        totalDiscovered: hits.length,
+        promotedCandidates: promoted.length,
+        blockedCandidates: blocked.length,
+        guardExplanations: guardExplanations,
+        guardResults: guardResults,
+        promoted: promoted,
+        blocked: blocked,
+        promotionReasons: promotionReasons,
+        blockReasons: blockReasons,
+        mode: "report_only",
+        safeForDefaultRanking: false,
+    };
+}
+function cosineSimilarity(a, b) {
+    let dot = 0, normA = 0, normB = 0;
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+//# sourceMappingURL=semanticChunkIndex.js.map