flowseeker 0.1.7

package/dist/pipeline/ranker.js

@@ -0,0 +1,563 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rankEvidence = rankEvidence;
+const contextBlueprint_1 = require("./contextBlueprint");
+const text_1 = require("../utils/text");
+const subsystem_1 = require("./subsystem");
+const rolePriority = {
+    edit_candidate: 5,
+    read_context: 4,
+    test: 4,
+    impact: 3,
+    verify: 3,
+    unknown: 1
+};
+function rankEvidence(units, config, profile, rankOptions) {
+    const deduped = markDuplicateUnits(dedupeUnits(units).map((unit) => applyTaskMetadata(unit, profile)));
+    const fileCounts = new Map();
+    for (const unit of deduped) {
+        fileCounts.set(unit.relativePath, (fileCounts.get(unit.relativePath) ?? 0) + 1);
+    }
+    const boosted = deduped.map((unit) => boostUnit(unit, fileCounts, config, profile, rankOptions?.editorContext));
+    const sorted = boosted.sort(compareUnits);
+    if (!profile) {
+        return selectDiverseUnits(sorted, config.pipeline.maxCandidates);
+    }
+    return selectWithBlueprintCoverage(sorted, profile, config.pipeline.maxCandidates);
+}
+function dedupeUnits(units) {
+    const byId = new Map();
+    for (const unit of units) {
+        const existing = byId.get(unit.id);
+        if (!existing || unit.score > existing.score) {
+            byId.set(unit.id, unit);
+        }
+    }
+    return Array.from(byId.values());
+}
+function markDuplicateUnits(units) {
+    const seen = new Set();
+    return units.map((unit) => {
+        const dedupeKey = unit.dedupeKey ?? buildDedupeKey(unit);
+        const isDuplicate = seen.has(dedupeKey);
+        seen.add(dedupeKey);
+        return {
+            ...unit,
+            dedupeKey,
+            isDuplicate
+        };
+    });
+}
+function applyTaskMetadata(unit, profile) {
+    const dedupeKey = unit.dedupeKey ?? buildDedupeKey(unit);
+    if (!profile || profile.negativeTerms.length === 0) {
+        return { ...unit, dedupeKey };
+    }
+    const matchedNegativeTerms = matchedTaskNegativeTerms(unit, profile);
+    if (matchedNegativeTerms.length === 0) {
+        return { ...unit, dedupeKey };
+    }
+    const role = unit.role === "edit_candidate" || unit.role === "impact" ? "read_context" : unit.role;
+    return {
+        ...unit,
+        dedupeKey,
+        role,
+        contrastContext: true,
+        score: unit.score - 24,
+        reasons: [
+            ...unit.reasons,
+            `contrast context: matches avoided/previous behavior term(s) ${matchedNegativeTerms.join(", ")}`
+        ]
+    };
+}
+function matchedTaskNegativeTerms(unit, profile) {
+    const haystack = (0, text_1.normalizeText)(`${unit.relativePath}\n${unit.snippet ?? ""}`);
+    return profile.negativeTerms
+        .map(text_1.normalizeText)
+        .filter((term) => term.length > 1 && haystack.includes(term))
+        .slice(0, 5);
+}
+function selectDiverseUnits(sorted, maxCandidates) {
+    const state = createSelectionState(maxCandidates);
+    for (const unit of sorted) {
+        pushUnit(state, unit);
+    }
+    return state.selected;
+}
+function selectWithBlueprintCoverage(sorted, profile, maxCandidates) {
+    const state = createSelectionState(maxCandidates);
+    const constrainedTop = buildConstrainedTopK(sorted, profile, Math.min(10, maxCandidates));
+    for (const unit of constrainedTop) {
+        pushUnit(state, unit);
+    }
+    pushFrameworkCompanions(sorted, state);
+    for (const slot of profile.blueprint.requiredSlots) {
+        pushUnit(state, bestUnitForSlot(sorted, slot, state), { allowThirdFileUnit: true });
+    }
+    pushEntityCompanions(sorted, state, profile);
+    for (const slot of (0, contextBlueprint_1.allContextSlots)(profile.blueprint)) {
+        if (profile.blueprint.requiredSlots.includes(slot)) {
+            continue;
+        }
+        if (shouldSkipOptionalSlot(profile, slot)) {
+            continue;
+        }
+        pushUnit(state, bestUnitForSlot(sorted, slot, state));
+        if (state.selected.length >= Math.floor(maxCandidates * 0.65)) {
+            break;
+        }
+    }
+    for (const unit of sorted) {
+        pushUnit(state, unit);
+    }
+    return state.selected.slice(0, maxCandidates);
+}
+function buildConstrainedTopK(sorted, profile, limit) {
+    const pool = sorted.slice(0, Math.min(80, sorted.length));
+    const selected = [];
+    const seenIds = new Set();
+    const fileCounts = new Map();
+    const primarySubsystem = inferSelectionSubsystem(pool, profile);
+    const add = (unit, force = false) => {
+        if (!unit || selected.length >= limit || seenIds.has(unit.id)) {
+            return false;
+        }
+        const currentFileCount = fileCounts.get(unit.relativePath) ?? 0;
+        if (!force && currentFileCount >= 1) {
+            return false;
+        }
+        seenIds.add(unit.id);
+        fileCounts.set(unit.relativePath, currentFileCount + 1);
+        selected.push(unit);
+        return true;
+    };
+    for (const anchor of pool.filter((unit) => !unit.contrastContext).slice(0, 3)) {
+        add(anchor, true);
+    }
+    for (const slot of orderedRequiredSlots(profile)) {
+        add(bestConstrainedSlotUnit(pool, slot, profile, primarySubsystem, seenIds, fileCounts));
+    }
+    for (const unit of pool) {
+        if (selected.length >= limit) {
+            break;
+        }
+        if (!isAllowedInConstrainedTop(unit, profile, primarySubsystem)) {
+            continue;
+        }
+        add(unit);
+    }
+    for (const unit of sorted) {
+        if (selected.length >= limit) {
+            break;
+        }
+        add(unit);
+    }
+    return selected;
+}
+function orderedRequiredSlots(profile) {
+    const preferred = ["entry", "handler", "validation", "ui"];
+    const required = profile.blueprint.requiredSlots;
+    return [
+        ...preferred.filter((slot) => required.includes(slot)),
+        ...required.filter((slot) => !preferred.includes(slot))
+    ];
+}
+function bestConstrainedSlotUnit(pool, slot, profile, primarySubsystem, seenIds, fileCounts) {
+    return pool
+        .filter((unit) => unit.slot === slot && !seenIds.has(unit.id))
+        .filter((unit) => (fileCounts.get(unit.relativePath) ?? 0) === 0)
+        .filter((unit) => isAllowedInConstrainedTop(unit, profile, primarySubsystem) || hasStrongTaskMatch(unit, profile))
+        .sort((left, right) => constrainedCandidateScore(right, profile, primarySubsystem) - constrainedCandidateScore(left, profile, primarySubsystem))[0];
+}
+function constrainedCandidateScore(unit, profile, primarySubsystem) {
+    let score = unit.score;
+    if (hasStrongTaskMatch(unit, profile)) {
+        score += 60;
+    }
+    if (primarySubsystem && unit.subsystem === primarySubsystem) {
+        score += 24;
+    }
+    if (unit.contrastContext) {
+        score -= 80;
+    }
+    if (isUnrequestedTestEvidence(unit, profile)) {
+        score -= 50;
+    }
+    if (unit.slot === "entry" || unit.slot === "handler") {
+        score += 18;
+    }
+    if (unit.slot === "validation" || unit.slot === "ui") {
+        score += 12;
+    }
+    return score;
+}
+function isAllowedInConstrainedTop(unit, profile, primarySubsystem) {
+    if (unit.contrastContext) {
+        return false;
+    }
+    if (isUnrequestedTestEvidence(unit, profile)) {
+        return false;
+    }
+    if (!primarySubsystem || !unit.subsystem || unit.subsystem === primarySubsystem) {
+        return true;
+    }
+    if (unit.slot && profile.blueprint.requiredSlots.includes(unit.slot)) {
+        return true;
+    }
+    return hasStrongTaskMatch(unit, profile);
+}
+function inferSelectionSubsystem(pool, profile) {
+    const counts = new Map();
+    for (const unit of pool.slice(0, 30)) {
+        if (!unit.subsystem || unit.contrastContext) {
+            continue;
+        }
+        const weight = 1 + (hasStrongTaskMatch(unit, profile) ? 3 : 0) + (unit.slot && profile.blueprint.requiredSlots.includes(unit.slot) ? 1 : 0);
+        counts.set(unit.subsystem, (counts.get(unit.subsystem) ?? 0) + weight);
+    }
+    return Array.from(counts.entries()).sort((left, right) => right[1] - left[1])[0]?.[0];
+}
+function hasStrongTaskMatch(unit, profile) {
+    const matched = new Set(unit.matchedTerms.map(text_1.normalizeText));
+    if (profile.literalTerms.some((term) => matched.has((0, text_1.normalizeText)(term)))) {
+        return true;
+    }
+    const path = normalizePath(unit.relativePath);
+    return [...profile.literalTerms, ...profile.keywords]
+        .map((term) => (0, text_1.normalizeText)(term).replace(/[^a-z0-9]+/g, ""))
+        .some((term) => term.length >= 5 && path.replace(/[^a-z0-9]+/g, "").includes(term));
+}
+function createSelectionState(maxCandidates) {
+    return {
+        maxCandidates,
+        selected: [],
+        seenIds: new Set(),
+        seenDedupeKeys: new Set(),
+        fileCounts: new Map()
+    };
+}
+function pushUnit(state, unit, options = {}) {
+    if (!unit || state.selected.length >= state.maxCandidates || state.seenIds.has(unit.id)) {
+        return false;
+    }
+    const dedupeKey = unit.dedupeKey ?? buildDedupeKey(unit);
+    if (state.seenDedupeKeys.has(dedupeKey)) {
+        return false;
+    }
+    const currentFileCount = state.fileCounts.get(unit.relativePath) ?? 0;
+    const earlyLimit = options.allowSecondFileUnitEarly ? 2 : 1;
+    const fileLimit = state.selected.length < 12 ? earlyLimit : options.allowThirdFileUnit ? 3 : 2;
+    if (currentFileCount >= fileLimit) {
+        return false;
+    }
+    state.seenIds.add(unit.id);
+    state.seenDedupeKeys.add(dedupeKey);
+    state.fileCounts.set(unit.relativePath, currentFileCount + 1);
+    state.selected.push({ ...unit, dedupeKey });
+    return true;
+}
+function pushFrameworkCompanions(sorted, state) {
+    const byPath = new Map();
+    for (const unit of sorted) {
+        const key = normalizePath(unit.relativePath);
+        const list = byPath.get(key) ?? [];
+        list.push(unit);
+        byPath.set(key, list);
+    }
+    const companionPaths = new Map();
+    for (const unit of state.selected.slice(0, 8)) {
+        for (const companionPath of frameworkCompanionPaths(unit.relativePath)) {
+            companionPaths.set(companionPath, unit.relativePath);
+        }
+    }
+    for (const [companionPath, sourcePath] of companionPaths.entries()) {
+        if (state.selected.some((unit) => normalizePath(unit.relativePath) === companionPath)) {
+            continue;
+        }
+        const candidate = byPath.get(companionPath)?.find((unit) => !state.seenIds.has(unit.id) && !unit.contrastContext);
+        pushUnit(state, candidate ? withFrameworkReason(candidate, `framework companion of ${sourcePath}`) : undefined);
+    }
+}
+function pushEntityCompanions(sorted, state, profile) {
+    const entities = focusedEntityTerms(profile);
+    if (entities.length === 0 || state.selected.length >= state.maxCandidates) {
+        return;
+    }
+    const selectedText = normalizePath(state.selected.map((unit) => unit.relativePath).join(" "));
+    const activeEntities = entities.filter((entity) => selectedText.includes(entity));
+    const slotsToCover = profile.blueprint.requiredSlots.filter(isEntityCompanionSlot);
+    let added = 0;
+    for (const entity of activeEntities) {
+        for (const slot of slotsToCover) {
+            const companion = bestEntityCompanion(sorted, entity, slot, state);
+            if (pushUnit(state, companion ? withEntityCompanionReason(companion, entity, slot) : undefined, { allowThirdFileUnit: true })) {
+                added += 1;
+            }
+            if (added >= 3 || state.selected.length >= Math.floor(state.maxCandidates * 0.5)) {
+                return;
+            }
+        }
+    }
+}
+function isEntityCompanionSlot(slot) {
+    return slot === "data" || slot === "permission" || slot === "entry" || slot === "domain";
+}
+function shouldSkipOptionalSlot(profile, slot) {
+    if (slot === "tests") {
+        return !profileHasAny(profile, ["test", "tests", "spec", "expect", "assert", "verify", "verification", "kiem tra"]);
+    }
+    if (slot === "docs") {
+        return !profileHasAny(profile, ["docs", "documentation", "readme", "guide"]);
+    }
+    return false;
+}
+function profileHasAny(profile, values) {
+    const terms = new Set(profile.keywords.map(text_1.normalizeText));
+    return values.some((value) => terms.has((0, text_1.normalizeText)(value)));
+}
+function frameworkCompanionPaths(relativePath) {
+    const normalized = normalizePath(relativePath);
+    const svelteRoute = normalized.match(/^(.*\/routes\/.+\/)\+(page|layout|server)\.(svelte|ts|js)$/);
+    if (svelteRoute) {
+        const dir = svelteRoute[1];
+        return [
+            `${dir}+page.ts`,
+            `${dir}+page.js`,
+            `${dir}+page.svelte`,
+            `${dir}+server.ts`,
+            `${dir}+server.js`,
+            `${dir}+layout.ts`,
+            `${dir}+layout.svelte`
+        ].filter((candidate) => candidate !== normalized);
+    }
+    const nextRoute = normalized.match(/^(.*\/(?:app|pages)\/.+\/)(page|route|layout)\.(tsx|jsx|ts|js)$/);
+    if (nextRoute) {
+        const dir = nextRoute[1];
+        return [
+            `${dir}page.tsx`,
+            `${dir}page.jsx`,
+            `${dir}page.ts`,
+            `${dir}page.js`,
+            `${dir}route.ts`,
+            `${dir}route.js`,
+            `${dir}layout.tsx`,
+            `${dir}layout.jsx`
+        ].filter((candidate) => candidate !== normalized);
+    }
+    return [];
+}
+function bestUnitForSlot(units, slot, state) {
+    const candidates = units.filter((unit) => unit.slot === slot && !state.seenIds.has(unit.id));
+    return (candidates.find((unit) => !unit.contrastContext && (state.fileCounts.get(unit.relativePath) ?? 0) === 0) ??
+        candidates.find((unit) => !unit.contrastContext && (state.fileCounts.get(unit.relativePath) ?? 0) < 2) ??
+        candidates.find((unit) => (state.fileCounts.get(unit.relativePath) ?? 0) === 0) ??
+        candidates.find((unit) => (state.fileCounts.get(unit.relativePath) ?? 0) < 2));
+}
+function bestEntityCompanion(units, entity, slot, state) {
+    return units
+        .filter((unit) => unit.slot === slot && !unit.contrastContext && !state.seenIds.has(unit.id))
+        .filter((unit) => (state.fileCounts.get(unit.relativePath) ?? 0) === 0)
+        .filter((unit) => normalizePath(unit.relativePath).includes(entity))
+        .sort((left, right) => entityCompanionScore(right, entity, slot) - entityCompanionScore(left, entity, slot))[0];
+}
+function entityCompanionScore(unit, entity, slot) {
+    const normalizedPath = normalizePath(unit.relativePath);
+    const basename = normalizedPath.split("/").pop() ?? normalizedPath;
+    let score = unit.score;
+    if (basename.startsWith(`${entity}.`) || basename.startsWith(`${entity}_`)) {
+        score += 36;
+    }
+    if (normalizedPath.includes(`${entity}_${entity}`) || normalizedPath.includes(`${entity}_policy`)) {
+        score += 46;
+    }
+    if (slot === "data" && /\b(migration|migrations|create_|alter_|add_)\b/.test(normalizedPath)) {
+        score += 34;
+    }
+    if (slot === "permission" && /(^|\/)(policies?|permissions?)(\/|$)/.test(normalizedPath)) {
+        score += 30;
+    }
+    return score;
+}
+function withEntityCompanionReason(unit, entity, slot) {
+    const normalizedPath = normalizePath(unit.relativePath);
+    const migrationBoost = slot === "data" && /\b(migration|migrations|create_|alter_|add_)\b/.test(normalizedPath) ? 68 : 0;
+    const policyBoost = slot === "permission" && /(^|\/)(policies?|permissions?)(\/|$)/.test(normalizedPath) ? 48 : 0;
+    const boost = Math.max(24, migrationBoost, policyBoost);
+    const score = unit.score + boost;
+    return {
+        ...unit,
+        score,
+        confidence: (0, text_1.clamp)(score / 30, 0.1, 0.98),
+        tier: score >= 22.5 ? "high" : score >= 13.5 ? "medium" : "low",
+        reasons: [...unit.reasons, `entity companion for ${entity} ${slot} context`]
+    };
+}
+function boostUnit(unit, fileCounts, config, profile, editorContext) {
+    const sameFileCount = fileCounts.get(unit.relativePath) ?? 1;
+    const crossEvidenceBonus = Math.min(4, sameFileCount - 1);
+    const multiTermBonus = Math.min(6, unit.matchedTerms.length);
+    const slotBonus = profile ? profileSlotBonus(unit, profile) : 0;
+    const subsystemBonus = profile ? (0, subsystem_1.subsystemAlignmentScore)(unit, profile) : 0;
+    const symbolBonus = profile && unit.symbolMatches?.length ? Math.min(8, unit.symbolMatches.length * 4) : 0;
+    const literalTermBonus = profile ? matchedTaskLiteralBonus(unit, profile) : 0;
+    const filenamePhraseBonus = profile ? filenamePhraseMatchBonus(unit, profile) : 0;
+    const testPenalty = profile && isUnrequestedTestEvidence(unit, profile) ? 55 : 0;
+    const duplicatePenalty = unit.isDuplicate ? 8 : 0;
+    const contrastPenalty = unit.contrastContext ? 8 : 0;
+    const editorBoost = editorContext ? editorContextBoost(unit, editorContext) : 0;
+    const score = unit.score + crossEvidenceBonus + multiTermBonus + slotBonus + subsystemBonus + symbolBonus + literalTermBonus + filenamePhraseBonus - testPenalty - duplicatePenalty - contrastPenalty + editorBoost;
+    const confidence = (0, text_1.clamp)(score / 30, 0.1, 0.98);
+    const role = confidence < config.pipeline.minConfidence && unit.role === "edit_candidate" ? "unknown" : unit.role;
+    return {
+        ...unit,
+        score,
+        role,
+        confidence,
+        tier: confidence >= 0.75 ? "high" : confidence >= config.pipeline.minConfidence ? "medium" : "low",
+        reasons: [
+            ...unit.reasons,
+            crossEvidenceBonus > 0 ? "multiple related regions in same file" : "",
+            slotBonus > 0 ? "blueprint slot coverage" : "",
+            subsystemBonus > 0 ? "subsystem alignment" : "",
+            subsystemBonus < 0 ? "possible subsystem mismatch" : "",
+            symbolBonus > 0 ? "symbol-name match" : "",
+            literalTermBonus > 0 ? "exact literal value match" : "",
+            filenamePhraseBonus > 0 ? "filename phrase match" : "",
+            testPenalty > 0 ? "test evidence deprioritized" : "",
+            unit.isDuplicate ? "duplicate evidence deprioritized" : "",
+            editorBoost > 0 ? "active editor context boost" : ""
+        ].filter(Boolean)
+    };
+}
+function isUnrequestedTestEvidence(unit, profile) {
+    if (unit.kind !== "test" && unit.slot !== "tests") {
+        return false;
+    }
+    return !/\b(test|tests|spec|unit test|integration test|e2e|assert|expect|coverage)\b/.test(profile.normalizedTask);
+}
+function filenamePhraseMatchBonus(unit, profile) {
+    const normalizedPath = normalizePath(unit.relativePath);
+    const base = normalizedPath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? normalizedPath;
+    const compactBase = base.replace(/[^a-z0-9]+/g, "");
+    const compactPath = normalizedPath.replace(/[^a-z0-9]+/g, "");
+    let best = 0;
+    for (const term of [...profile.literalTerms, ...profile.keywords]) {
+        const compactTerm = (0, text_1.normalizeText)(term).replace(/[^a-z0-9]+/g, "");
+        if (compactTerm.length < 5) {
+            continue;
+        }
+        if (compactBase.includes(compactTerm)) {
+            best = Math.max(best, 64);
+        }
+        else if (compactPath.includes(compactTerm)) {
+            best = Math.max(best, 28);
+        }
+    }
+    if (/\b(source\s+code|source|src|implementation)\b/.test(profile.normalizedTask) && normalizedPath.startsWith("src/")) {
+        best += 18;
+    }
+    return best;
+}
+function matchedTaskLiteralBonus(unit, profile) {
+    if (profile.literalTerms.length === 0) {
+        return 0;
+    }
+    const literals = new Set(profile.literalTerms);
+    const matchedLiteral = unit.matchedTerms.find((term) => literals.has(term));
+    if (!matchedLiteral) {
+        return 0;
+    }
+    return isValueOrPathLiteral(matchedLiteral) ? 88 : 72;
+}
+function isValueOrPathLiteral(term) {
+    return term.length >= 8 && (term.includes("/") || term.includes("@") || term.includes("://"));
+}
+function hasSpecificMatchedTerm(unit) {
+    return unit.matchedTerms.some((term) => {
+        if (term.length >= 14 && !term.includes(" ")) {
+            return true;
+        }
+        if (!term.includes("_")) {
+            return false;
+        }
+        return term.split("_").filter((part) => part.length > 1).length >= 3;
+    });
+}
+function profileSlotBonus(unit, profile) {
+    const slot = unit.slot ?? "unknown";
+    let bonus = 0;
+    if (profile.blueprint.requiredSlots.includes(slot)) {
+        bonus += 14;
+    }
+    else if (profile.blueprint.optionalSlots.includes(slot)) {
+        bonus += 5;
+    }
+    if (profile.blueprint.primarySurface === "frontend" && (slot === "entry" || slot === "ui" || slot === "domain")) {
+        bonus += 4;
+    }
+    if (profile.blueprint.primarySurface === "backend" && ["entry", "handler", "domain", "data", "validation", "permission", "side_effect"].includes(slot)) {
+        bonus += 3;
+    }
+    return bonus;
+}
+function compareUnits(a, b) {
+    const roleDelta = rolePriority[b.role] - rolePriority[a.role];
+    if (roleDelta !== 0) {
+        return roleDelta;
+    }
+    if (a.contrastContext !== b.contrastContext) {
+        return a.contrastContext ? 1 : -1;
+    }
+    return b.score - a.score;
+}
+function withFrameworkReason(unit, reason) {
+    return {
+        ...unit,
+        frameworkEdgeReason: unit.frameworkEdgeReason ?? reason,
+        reasons: [...unit.reasons, reason]
+    };
+}
+const lowSignalEntityTerms = new Set(["user", "account", "member", "admin", "file", "document", "submission", "attachment"]);
+function focusedEntityTerms(profile) {
+    return profile.entities.map(text_1.normalizeText).filter((term) => term.length > 2 && !lowSignalEntityTerms.has(term));
+}
+function buildDedupeKey(unit) {
+    const normalizedPath = normalizePath(unit.relativePath);
+    const slot = unit.slot ?? "unknown";
+    if (unit.name) {
+        return `${normalizedPath}:${slot}:${unit.kind}:${(0, text_1.normalizeText)(unit.name)}`;
+    }
+    const startLine = unit.range?.startLine ?? 1;
+    const bucket = Math.floor(Math.max(0, startLine - 1) / 20);
+    return `${normalizedPath}:${slot}:${unit.kind}:${bucket}`;
+}
+function normalizePath(relativePath) {
+    return relativePath.replace(/\\/g, "/").toLowerCase();
+}
+function editorContextBoost(unit, ctx) {
+    if (!ctx) {
+        return 0;
+    }
+    const path = normalizePath(unit.relativePath);
+    let boost = 0;
+    if (ctx.activeFile) {
+        const activePath = normalizePath(ctx.activeFile);
+        if (path === activePath) {
+            boost += 15;
+        }
+        else {
+            const activeDir = activePath.substring(0, activePath.lastIndexOf("/"));
+            if (path.startsWith(activeDir + "/")) {
+                boost += 5;
+            }
+        }
+    }
+    if (ctx.recentFiles) {
+        const recent = ctx.recentFiles.map(normalizePath);
+        if (recent.includes(path)) {
+            boost += 8;
+        }
+    }
+    return boost;
+}
+//# sourceMappingURL=ranker.js.map

package/dist/pipeline/responseLanguage.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildResponseLanguageInstruction = buildResponseLanguageInstruction;
+const text_1 = require("../utils/text");
+function buildResponseLanguageInstruction(configuredLanguage, task) {
+    if (configuredLanguage === "vi") {
+        return "Respond in Vietnamese.";
+    }
+    if (configuredLanguage === "en") {
+        return "Respond in English only.";
+    }
+    const detected = detectTaskLanguage(task);
+    if (detected === "vi") {
+        return "Respond in Vietnamese. The user's task is written in Vietnamese.";
+    }
+    if (detected === "en") {
+        return "Respond in English. The user's task is written in English.";
+    }
+    return "Respond in the same language as the user's task.";
+}
+function detectTaskLanguage(task) {
+    const normalized = (0, text_1.normalizeText)(task).replace(/[^a-z0-9]+/g, " ");
+    const tokens = normalized.split(/\s+/).filter(Boolean);
+    const hasVietnameseMarks = /[\u0300-\u036f]/.test(task.normalize("NFD")) || /[\u0111\u0110]/.test(task);
+    const viSignals = countSignals(tokens, ["toi", "muon", "sua", "them", "xoa", "duyet", "trinh", "khong", "bang", "cho", "sau", "truoc", "thay", "doi", "nguoi", "hoc", "vien", "du", "lieu", "loi"]);
+    const enSignals = countSignals(tokens, ["fix", "change", "update", "add", "remove", "delete", "user", "browser", "file", "code", "when", "after", "before", "instead", "only", "should"]);
+    if (hasVietnameseMarks || viSignals >= 2) {
+        return "vi";
+    }
+    if (enSignals >= 2) {
+        return "en";
+    }
+    return "unknown";
+}
+function countSignals(tokens, signals) {
+    const tokenSet = new Set(tokens);
+    return signals.filter((signal) => tokenSet.has(signal)).length;
+}
+//# sourceMappingURL=responseLanguage.js.map