@jungjaehoon/mama-core 1.4.2 → 1.5.0

package/dist/search/feedback-store.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashQuery = hashQuery;
+exports.getFeedbackRetentionDays = getFeedbackRetentionDays;
+exports.compactShownSearchFeedback = compactShownSearchFeedback;
+exports.recordSearchFeedback = recordSearchFeedback;
+exports.listSearchFeedback = listSearchFeedback;
+const node_crypto_1 = require("node:crypto");
+const question_type_js_1 = require("./question-type.js");
+const DEFAULT_RETENTION_DAYS = 180;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function normalizedQuery(query) {
+    return query.trim().toLowerCase();
+}
+function fullQueryHashHex(query) {
+    return (0, node_crypto_1.createHash)('sha256').update(normalizedQuery(query)).digest('hex');
+}
+function fullQueryHashBuffer(query) {
+    return Buffer.from(fullQueryHashHex(query), 'hex');
+}
+function hashQuery(query) {
+    return fullQueryHashHex(query).slice(0, 16);
+}
+function assertNonEmpty(value, field) {
+    if (!value || value.trim().length === 0) {
+        throw new Error(`${field} is required`);
+    }
+}
+function assertRank(value, field) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${field} must be a non-negative integer`);
+    }
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function cutoffIso(retentionDays, now = new Date()) {
+    return new Date(now.getTime() - retentionDays * MS_PER_DAY).toISOString();
+}
+function stableObject(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stableObject(item));
+    }
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    const input = value;
+    const output = {};
+    for (const key of Object.keys(input).sort((left, right) => left.localeCompare(right))) {
+        const item = input[key];
+        if (item !== undefined) {
+            output[key] = stableObject(item);
+        }
+    }
+    return output;
+}
+function canonicalJson(value) {
+    return JSON.stringify(stableObject(value));
+}
+function runTransaction(adapter, fn) {
+    if (!adapter.transaction) {
+        throw new Error('recordSearchFeedback requires adapter.transaction for atomic writes.');
+    }
+    const result = adapter.transaction(fn);
+    if (typeof result === 'function') {
+        return result();
+    }
+    return result;
+}
+function parseRetentionValue(value) {
+    const parsed = JSON.parse(value);
+    const numeric = typeof parsed === 'number' ? parsed : Number(parsed);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        throw new Error(`Invalid search_feedback_retention_days value: ${value}`);
+    }
+    return Math.floor(numeric);
+}
+function getFeedbackRetentionDays(adapter) {
+    const row = adapter
+        .prepare(`
+        SELECT value_json
+        FROM search_ranker_settings
+        WHERE key = 'search_feedback_retention_days'
+      `)
+        .get();
+    if (!row?.value_json) {
+        return DEFAULT_RETENTION_DAYS;
+    }
+    return parseRetentionValue(row.value_json);
+}
+function compactShownSearchFeedback(adapter, retentionDays = getFeedbackRetentionDays(adapter)) {
+    const result = adapter
+        .prepare(`
+        DELETE FROM search_feedback
+        WHERE feedback_kind = 'shown'
+          AND created_at < ?
+      `)
+        .run(cutoffIso(retentionDays));
+    return result.changes;
+}
+function sessionForInput(input, queryHash) {
+    if (input.session_id && input.session_id.trim().length > 0) {
+        return input.session_id;
+    }
+    if (input.feedback_kind === 'shown') {
+        return `anonymous:${queryHash}`;
+    }
+    return input.session_id ?? null;
+}
+function rankPositionForInput(input) {
+    if (input.feedback_kind === 'click' && input.clicked_result_rank !== undefined) {
+        const rank = input.clicked_result_rank ?? input.shown_index;
+        assertRank(rank, 'clicked_result_rank');
+        return rank;
+    }
+    assertRank(input.shown_index, 'shown_index');
+    return input.shown_index;
+}
+function questionTypeForInput(input) {
+    if (input.question_type && (0, question_type_js_1.isQuestionType)(input.question_type)) {
+        return input.question_type;
+    }
+    return (0, question_type_js_1.classifyQuestionType)(input.query);
+}
+function recordSearchFeedback(adapter, input) {
+    assertNonEmpty(input.result_id, 'result_id');
+    assertNonEmpty(input.query, 'query');
+    assertNonEmpty(input.result_source_type, 'result_source_type');
+    assertNonEmpty(input.result_source_id, 'result_source_id');
+    const queryHashHex = fullQueryHashHex(input.query);
+    const queryHash = fullQueryHashBuffer(input.query);
+    const queryHashShort = queryHashHex.slice(0, 16);
+    const sessionId = sessionForInput(input, queryHashShort);
+    const questionType = questionTypeForInput(input);
+    const rankPosition = rankPositionForInput(input);
+    const createdAt = input.created_at ?? nowIso();
+    const feedbackId = `search_feedback_${(0, node_crypto_1.randomUUID)()}`;
+    const metadataJson = canonicalJson({
+        clicked_result_rank: input.clicked_result_rank ?? null,
+        input_result_id: input.result_id,
+    });
+    return runTransaction(adapter, () => {
+        let deduped = false;
+        if (input.feedback_kind === 'shown') {
+            compactShownSearchFeedback(adapter);
+            if (sessionId) {
+                const deleted = adapter
+                    .prepare(`
+              DELETE FROM search_feedback
+              WHERE feedback_kind = 'shown'
+                AND session_id = ?
+                AND query_hash = ?
+                AND result_source_type = ?
+                AND result_source_id = ?
+            `)
+                    .run(sessionId, queryHash, input.result_source_type, input.result_source_id);
+                deduped = deleted.changes > 0;
+            }
+        }
+        adapter
+            .prepare(`
+          INSERT INTO search_feedback (
+            feedback_id, query, query_hash, question_type, result_source_type, result_source_id,
+            case_id, feedback_kind, rank_position, score_before, score_after, session_id,
+            actor, metadata_json, created_at, updated_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 'system:search-feedback', ?, ?, NULL)
+        `)
+            .run(feedbackId, input.query, queryHash, questionType, input.result_source_type, input.result_source_id, input.result_case_id ?? null, input.feedback_kind, rankPosition, sessionId, metadataJson, createdAt);
+        return {
+            feedback_id: feedbackId,
+            query_hash: queryHashShort,
+            deduped,
+        };
+    });
+}
+function listSearchFeedback(adapter, options = {}) {
+    const retentionDays = getFeedbackRetentionDays(adapter);
+    const until = options.until ?? nowIso();
+    const since = options.since ?? cutoffIso(retentionDays, new Date(until));
+    const limit = options.limit ?? 10_000;
+    assertRank(limit, 'limit');
+    const rows = adapter
+        .prepare(`
+        SELECT
+          feedback_id,
+          query,
+          lower(hex(query_hash)) AS query_hash_hex,
+          question_type,
+          result_source_type,
+          result_source_id,
+          case_id,
+          feedback_kind,
+          rank_position,
+          score_before,
+          score_after,
+          session_id,
+          actor,
+          metadata_json,
+          created_at,
+          updated_at
+        FROM search_feedback
+        WHERE created_at >= ?
+          AND created_at <= ?
+        ORDER BY created_at ASC, feedback_id ASC
+        LIMIT ?
+      `)
+        .all(since, until, limit);
+    return rows;
+}
+//# sourceMappingURL=feedback-store.js.map

package/dist/search/question-type.d.ts

@@ -0,0 +1,5 @@
+export type QuestionType = 'correction' | 'artifact' | 'timeline' | 'status' | 'decision_reason' | 'how_to' | 'unknown';
+export declare const QUESTION_TYPES: readonly QuestionType[];
+export declare function classifyQuestionType(query: string): QuestionType;
+export declare function isQuestionType(value: string): value is QuestionType;
+//# sourceMappingURL=question-type.d.ts.map

package/dist/search/question-type.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUESTION_TYPES = void 0;
+exports.classifyQuestionType = classifyQuestionType;
+exports.isQuestionType = isQuestionType;
+exports.QUESTION_TYPES = [
+    'correction',
+    'artifact',
+    'timeline',
+    'status',
+    'decision_reason',
+    'how_to',
+    'unknown',
+];
+// Korean: patterns for classifyQuestionType() multilingual query routing.
+const CORRECTION_PATTERN = /\b(fix|revert|correct|correction|supersede|superseded|revise|revision|수정|되돌|정정|교정)\b/i; // Korean: keywords
+const ARTIFACT_PATTERN = /\b(file|doc|docs|document|image|video|pdf|drive|obsidian|attachment|artifact|파일|문서|이미지|영상|첨부|드라이브|옵시디언)\b/i; // Korean: keywords
+const TIMELINE_PATTERN = /\b(when|history|before|after|around|timeline|chronology|언제|이력|히스토리|전|후|즈음)\b|\bon\s+\d{4}(?:-\d{1,2})?(?:-\d{1,2})?\b|\b\d{4}-\d{1,2}-\d{1,2}\b/i; // Korean: keywords
+const STATUS_PATTERN = /\b(status|state|current|currently|now|latest|progress|blocked|done|상태|현재|최신|진행|진척)\b/i; // Korean: keywords
+const DECISION_REASON_PATTERN = /\b(why|reason|because|rationale|근거|이유|왜|때문)\b/i; // Korean: keywords
+const HOW_TO_PATTERN = /\b(how\s+to|how\s+do|setup|set\s+up|configure|configuration|install|설정|구성|어떻게)\b/i; // Korean: keywords
+function classifyQuestionType(query) {
+    const normalized = query.trim();
+    if (CORRECTION_PATTERN.test(normalized))
+        return 'correction';
+    if (ARTIFACT_PATTERN.test(normalized))
+        return 'artifact';
+    if (TIMELINE_PATTERN.test(normalized))
+        return 'timeline';
+    if (STATUS_PATTERN.test(normalized))
+        return 'status';
+    if (DECISION_REASON_PATTERN.test(normalized))
+        return 'decision_reason';
+    if (HOW_TO_PATTERN.test(normalized))
+        return 'how_to';
+    return 'unknown';
+}
+function isQuestionType(value) {
+    return exports.QUESTION_TYPES.includes(value);
+}
+//# sourceMappingURL=question-type.js.map

package/dist/search/ranker-features.d.ts

@@ -0,0 +1,23 @@
+import { type QuestionType } from './question-type.js';
+export declare const SEARCH_RANKER_FEATURE_SET_VERSION = "v1.0.0";
+export type RankerSourceType = 'decision' | 'event' | 'observation' | 'artifact' | 'connector_event';
+export declare const RANKER_SOURCE_TYPES: readonly RankerSourceType[];
+export interface RankerFeatureVector {
+    bm25_score: number;
+    vector_score: number;
+    case_rollup_score: number;
+    recency_score: number;
+    same_case_boost: number;
+    source_type_onehot: Record<RankerSourceType, number>;
+    question_type_onehot: Record<QuestionType, number>;
+}
+export interface RankerQueryMeta {
+    question_type?: QuestionType;
+    case_id?: string | null;
+}
+type FeatureRow = Record<string, unknown>;
+export declare function extractFeatures(row: FeatureRow, query: string, queryMeta?: RankerQueryMeta): RankerFeatureVector;
+export declare function serializeFeatures(vec: RankerFeatureVector): number[];
+export declare function featureSetVersion(): string;
+export {};
+//# sourceMappingURL=ranker-features.d.ts.map

package/dist/search/ranker-features.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANKER_SOURCE_TYPES = exports.SEARCH_RANKER_FEATURE_SET_VERSION = void 0;
+exports.extractFeatures = extractFeatures;
+exports.serializeFeatures = serializeFeatures;
+exports.featureSetVersion = featureSetVersion;
+const question_type_js_1 = require("./question-type.js");
+exports.SEARCH_RANKER_FEATURE_SET_VERSION = 'v1.0.0';
+exports.RANKER_SOURCE_TYPES = [
+    'decision',
+    'event',
+    'observation',
+    'artifact',
+    'connector_event',
+];
+function numberValue(value, fallback = 0) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return value;
+}
+function stringValue(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return String(value);
+}
+function sourceTypeKey(row) {
+    const sourceType = stringValue(row.source_type ?? row.result_source_type ?? row.kind ?? row.page_type);
+    switch (sourceType) {
+        case 'decision':
+            return 'decision';
+        case 'event':
+        case 'checkpoint':
+            return 'event';
+        case 'observation':
+        case 'case':
+            return 'observation';
+        case 'artifact':
+        case 'wiki_page':
+            return 'artifact';
+        case 'connector_event':
+        case 'standalone_connector_hit':
+            return 'connector_event';
+        default:
+            return null;
+    }
+}
+function zeroSourceOnehot() {
+    return {
+        decision: 0,
+        event: 0,
+        observation: 0,
+        artifact: 0,
+        connector_event: 0,
+    };
+}
+function zeroQuestionOnehot() {
+    return {
+        correction: 0,
+        artifact: 0,
+        timeline: 0,
+        status: 0,
+        decision_reason: 0,
+        how_to: 0,
+        unknown: 0,
+    };
+}
+function extractFeatures(row, query, queryMeta = {}) {
+    const sourceOnehot = zeroSourceOnehot();
+    const sourceType = sourceTypeKey(row);
+    if (sourceType) {
+        sourceOnehot[sourceType] = 1;
+    }
+    const questionType = queryMeta.question_type ?? (0, question_type_js_1.classifyQuestionType)(query);
+    const questionOnehot = zeroQuestionOnehot();
+    questionOnehot[questionType] = 1;
+    const rowCaseId = stringValue(row.case_id ?? row.result_case_id);
+    const queryCaseId = queryMeta.case_id ?? null;
+    return {
+        bm25_score: numberValue(row.bm25_score ?? row.bm25 ?? row.fts_score),
+        vector_score: numberValue(row.vector_score ?? row.similarity),
+        case_rollup_score: numberValue(row.case_rollup_score ?? row.retrieval_score ?? row.final_score ?? row.score),
+        recency_score: numberValue(row.recency_score),
+        same_case_boost: queryCaseId && rowCaseId && queryCaseId === rowCaseId ? 1 : 0,
+        source_type_onehot: sourceOnehot,
+        question_type_onehot: questionOnehot,
+    };
+}
+function serializeFeatures(vec) {
+    return [
+        vec.bm25_score,
+        vec.vector_score,
+        vec.case_rollup_score,
+        vec.recency_score,
+        vec.same_case_boost,
+        ...exports.RANKER_SOURCE_TYPES.map((sourceType) => vec.source_type_onehot[sourceType]),
+        ...question_type_js_1.QUESTION_TYPES.map((questionType) => vec.question_type_onehot[questionType]),
+    ];
+}
+function featureSetVersion() {
+    return exports.SEARCH_RANKER_FEATURE_SET_VERSION;
+}
+//# sourceMappingURL=ranker-features.js.map

package/dist/search/ranker-rescore.d.ts

@@ -0,0 +1,31 @@
+import type { RunResult } from '../db-adapter/statement.js';
+import { type SearchRankerModel } from './ranker-trainer.js';
+export type SearchRankerSkippedReason = 'feature_disabled' | 'no_active_model' | 'feature_set_mismatch' | 'quality_gate_failed' | 'insufficient_result_count' | 'llm_reranking_requested';
+export interface RankerRescoreAdapter {
+    prepare(sql: string): {
+        run(...params: unknown[]): RunResult;
+        get(...params: unknown[]): unknown;
+        all(...params: unknown[]): unknown[];
+    };
+}
+export interface RankerScoredFields {
+    ranker_score?: number;
+    score_before_ranker?: number;
+    final_score?: number;
+}
+export interface RescoreSearchResultsOptions<T> {
+    query: string;
+    results: T[];
+    featureEnabled?: boolean;
+    useReranking?: boolean;
+}
+export interface RescoreSearchResultsResult<T> {
+    results: Array<T & RankerScoredFields>;
+    model_id: string | null;
+    skipped_reason?: SearchRankerSkippedReason;
+}
+export declare function loadActiveSearchRankerModel(adapter: RankerRescoreAdapter): SearchRankerModel | null;
+export declare function isSearchRankerEnabled(adapter: RankerRescoreAdapter): boolean;
+export declare function rescoreSearchResults<T extends Record<string, unknown>>(adapter: RankerRescoreAdapter, options: RescoreSearchResultsOptions<T>): RescoreSearchResultsResult<T>;
+export declare function logisticScoreForRow(model: SearchRankerModel, row: Record<string, unknown>, query: string): number;
+//# sourceMappingURL=ranker-rescore.d.ts.map

package/dist/search/ranker-rescore.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadActiveSearchRankerModel = loadActiveSearchRankerModel;
+exports.isSearchRankerEnabled = isSearchRankerEnabled;
+exports.rescoreSearchResults = rescoreSearchResults;
+exports.logisticScoreForRow = logisticScoreForRow;
+const ranker_features_js_1 = require("./ranker-features.js");
+const ranker_trainer_js_1 = require("./ranker-trainer.js");
+const question_type_js_1 = require("./question-type.js");
+function parseJsonObject(value) {
+    const parsed = JSON.parse(value);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('Expected JSON object');
+    }
+    return parsed;
+}
+function parseNumberArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.map((item) => (typeof item === 'number' && Number.isFinite(item) ? item : 0));
+}
+function parseQuestionWeights(value, fallback) {
+    const object = typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        correction: parseNumberArray(object.correction).length > 0
+            ? parseNumberArray(object.correction)
+            : [...fallback],
+        artifact: parseNumberArray(object.artifact).length > 0
+            ? parseNumberArray(object.artifact)
+            : [...fallback],
+        timeline: parseNumberArray(object.timeline).length > 0
+            ? parseNumberArray(object.timeline)
+            : [...fallback],
+        status: parseNumberArray(object.status).length > 0 ? parseNumberArray(object.status) : [...fallback],
+        decision_reason: parseNumberArray(object.decision_reason).length > 0
+            ? parseNumberArray(object.decision_reason)
+            : [...fallback],
+        how_to: parseNumberArray(object.how_to).length > 0 ? parseNumberArray(object.how_to) : [...fallback],
+        unknown: parseNumberArray(object.unknown).length > 0
+            ? parseNumberArray(object.unknown)
+            : [...fallback],
+    };
+}
+function modelFromRow(row) {
+    const payload = parseJsonObject(row.coefficients_json);
+    const coefficients = parseNumberArray(payload.coefficients);
+    const intercept = typeof payload.intercept === 'number' ? payload.intercept : 0;
+    const trainingRowsCount = typeof payload.training_rows_count === 'number' ? payload.training_rows_count : 0;
+    return {
+        model_id: row.model_id,
+        feature_set_version: row.feature_set_version,
+        trained_at: row.trained_at,
+        training_rows_count: trainingRowsCount,
+        coefficients,
+        intercept,
+        question_type_weights: parseQuestionWeights(payload.question_type_weights, coefficients),
+    };
+}
+function loadActiveRow(adapter) {
+    const row = adapter
+        .prepare(`
+        SELECT model_id, feature_set_version, coefficients_json, quality_gate_status, trained_at
+        FROM ranker_model_versions
+        WHERE active = 1
+        ORDER BY trained_at DESC
+        LIMIT 1
+      `)
+        .get();
+    return row ?? null;
+}
+function logSkipped(reason, modelId) {
+    console.warn(JSON.stringify({
+        event: 'search_ranker_skipped',
+        skipped_reason: reason,
+        model_id: modelId,
+        feature_set_version: ranker_features_js_1.SEARCH_RANKER_FEATURE_SET_VERSION,
+    }));
+}
+function loadActiveSearchRankerModel(adapter) {
+    const row = loadActiveRow(adapter);
+    if (!row) {
+        return null;
+    }
+    if (row.feature_set_version !== ranker_features_js_1.SEARCH_RANKER_FEATURE_SET_VERSION) {
+        logSkipped('feature_set_mismatch', row.model_id);
+        return null;
+    }
+    return modelFromRow(row);
+}
+function isSearchRankerEnabled(adapter) {
+    const row = adapter
+        .prepare(`
+        SELECT value_json
+        FROM search_ranker_settings
+        WHERE key = 'search_ranker_enabled'
+      `)
+        .get();
+    if (!row?.value_json) {
+        return true;
+    }
+    const parsed = JSON.parse(row.value_json);
+    return parsed !== false;
+}
+function baseScore(row) {
+    const candidates = [
+        row.final_score,
+        row.retrieval_score,
+        row.score,
+        row.similarity,
+        row.confidence,
+        row.case_rollup_score,
+        row.vector_score,
+        row.bm25_score,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+            return candidate;
+        }
+    }
+    return 0;
+}
+function resultId(row, fallback) {
+    const id = row.id ?? row.source_id ?? row.result_source_id;
+    return id === undefined || id === null ? String(fallback) : String(id);
+}
+function rescoreSearchResults(adapter, options) {
+    const passthrough = options.results;
+    if (options.useReranking) {
+        return {
+            results: passthrough,
+            model_id: null,
+            skipped_reason: 'llm_reranking_requested',
+        };
+    }
+    if (options.featureEnabled === false) {
+        return {
+            results: passthrough,
+            model_id: null,
+            skipped_reason: 'feature_disabled',
+        };
+    }
+    if (options.results.length < 2) {
+        return {
+            results: passthrough,
+            model_id: null,
+            skipped_reason: 'insufficient_result_count',
+        };
+    }
+    const row = loadActiveRow(adapter);
+    if (!row) {
+        return {
+            results: passthrough,
+            model_id: null,
+            skipped_reason: 'no_active_model',
+        };
+    }
+    if (row.feature_set_version !== ranker_features_js_1.SEARCH_RANKER_FEATURE_SET_VERSION) {
+        logSkipped('feature_set_mismatch', row.model_id);
+        return {
+            results: passthrough,
+            model_id: row.model_id,
+            skipped_reason: 'feature_set_mismatch',
+        };
+    }
+    if (row.quality_gate_status === 'failed') {
+        return {
+            results: passthrough,
+            model_id: row.model_id,
+            skipped_reason: 'quality_gate_failed',
+        };
+    }
+    if (row.quality_gate_status !== 'passed') {
+        return {
+            results: passthrough,
+            model_id: row.model_id,
+            skipped_reason: 'quality_gate_failed',
+        };
+    }
+    const model = modelFromRow(row);
+    const questionType = (0, question_type_js_1.classifyQuestionType)(options.query);
+    const scored = options.results.map((result, index) => {
+        const scoreBeforeRanker = baseScore(result);
+        const rankerScore = (0, ranker_trainer_js_1.scoreWithRankerModel)(model, result, options.query, questionType);
+        const finalScore = 0.8 * scoreBeforeRanker + 0.2 * rankerScore;
+        return {
+            result: {
+                ...result,
+                ranker_score: rankerScore,
+                score_before_ranker: scoreBeforeRanker,
+                final_score: finalScore,
+            },
+            index,
+            id: resultId(result, index),
+            finalScore,
+        };
+    });
+    scored.sort((left, right) => {
+        const diff = right.finalScore - left.finalScore;
+        if (Math.abs(diff) > 1e-12)
+            return diff;
+        if (left.index !== right.index)
+            return left.index - right.index;
+        return left.id.localeCompare(right.id);
+    });
+    return {
+        results: scored.map((entry) => entry.result),
+        model_id: model.model_id,
+    };
+}
+function logisticScoreForRow(model, row, query) {
+    const questionType = (0, question_type_js_1.classifyQuestionType)(query);
+    const features = (0, ranker_features_js_1.serializeFeatures)((0, ranker_features_js_1.extractFeatures)(row, query, { question_type: questionType }));
+    const coefficients = model.question_type_weights[questionType] ?? model.coefficients;
+    let score = model.intercept;
+    for (let index = 0; index < Math.min(coefficients.length, features.length); index += 1) {
+        score += coefficients[index] * features[index];
+    }
+    if (score >= 35)
+        return 1;
+    if (score <= -35)
+        return 0;
+    return 1 / (1 + Math.exp(-score));
+}
+//# sourceMappingURL=ranker-rescore.js.map