@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/cases/search-rollup.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollUpSearchHits = rollUpSearchHits;
+const store_js_1 = require("./store.js");
+function sourceKey(sourceType, sourceId) {
+    return `${sourceType}:${sourceId}`;
+}
+function objectRecord(value) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function stringOrNull(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return String(value);
+}
+function searchHitDiagnostics(value) {
+    const object = objectRecord(value);
+    if (!object) {
+        return undefined;
+    }
+    if (typeof object.retrieval_source !== 'string' ||
+        !(object.vector_similarity === null || typeof object.vector_similarity === 'number') ||
+        typeof object.is_vector_only !== 'boolean' ||
+        typeof object.lexical_support !== 'boolean' ||
+        typeof object.entity_support !== 'boolean' ||
+        typeof object.scope_support !== 'boolean' ||
+        (object.graph_source !== 'primary' &&
+            object.graph_source !== 'expanded' &&
+            object.graph_source !== null) ||
+        !Array.isArray(object.confirmation_signals) ||
+        !Array.isArray(object.metadata_signals) ||
+        typeof object.candidate_threshold_used !== 'number') {
+        return undefined;
+    }
+    // Type assertion is safe: every required field of SearchHitDiagnostics has been
+    // validated above (including the array-typed signals consumed by diagnosticsRank).
+    return value;
+}
+function leafDiagnostics(leaf) {
+    const record = objectRecord(leaf.record);
+    return leaf.retrieval_diagnostics ?? searchHitDiagnostics(record?.retrieval_diagnostics);
+}
+function diagnosticsRank(diagnostics) {
+    let rank = 0;
+    rank += diagnostics.confirmation_signals.length * 100;
+    if (diagnostics.lexical_support) {
+        rank += 20;
+    }
+    if (diagnostics.entity_support) {
+        rank += 20;
+    }
+    if (diagnostics.graph_source === 'primary') {
+        rank += 10;
+    }
+    if (!diagnostics.is_vector_only) {
+        rank += 1;
+    }
+    return rank;
+}
+function betterDiagnostics(candidate, current) {
+    if (!current) {
+        return true;
+    }
+    return diagnosticsRank(candidate) > diagnosticsRank(current);
+}
+function diagnosticsRecord(diagnosticsByLeaf) {
+    if (diagnosticsByLeaf.size === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(Array.from(diagnosticsByLeaf.entries()).sort(([left], [right]) => left.localeCompare(right)));
+}
+function attachLeafDiagnostics(group, leaf) {
+    const diagnostics = leafDiagnostics(leaf);
+    if (!diagnostics) {
+        return;
+    }
+    group.contributing_leaf_diagnostics.set(leaf.source_id, diagnostics);
+    if (betterDiagnostics(diagnostics, group.retrieval_diagnostics)) {
+        group.retrieval_diagnostics = diagnostics;
+    }
+}
+function placeholders(values) {
+    if (values.length === 0) {
+        throw new Error('Cannot build SQL IN clause for an empty value list.');
+    }
+    return values.map(() => '?').join(', ');
+}
+function withCaseId(record, caseId) {
+    const object = objectRecord(record);
+    if (!object) {
+        return { case_id: caseId };
+    }
+    return { ...object, case_id: caseId };
+}
+function loadCaseRecord(adapter, caseId) {
+    const row = adapter.prepare('SELECT * FROM case_truth WHERE case_id = ?').get(caseId);
+    return row ?? { case_id: caseId };
+}
+function canonicalCaseId(adapter, caseId) {
+    return (0, store_js_1.resolveCanonicalCaseChain)(adapter, caseId).terminal_case_id;
+}
+function listActiveMembershipCaseIds(adapter, sourceType, sourceId) {
+    const rows = adapter
+        .prepare(`
+        SELECT case_id
+        FROM case_memberships
+        WHERE source_type = ?
+          AND source_id = ?
+          AND status = 'active'
+      `)
+        .all(sourceType, sourceId);
+    return rows.map((row) => row.case_id);
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values.filter((value) => Boolean(value))));
+}
+function listConnectorEventMembershipCaseIds(adapter, leaf) {
+    const record = objectRecord(leaf.record) ?? {};
+    const sourceConnector = stringOrNull(record.source_connector);
+    const sourceLocator = stringOrNull(record.source_locator);
+    const artifactLocator = stringOrNull(record.artifact_locator);
+    const candidates = uniqueStrings([sourceLocator, artifactLocator]);
+    const caseIds = new Set();
+    if (sourceConnector && sourceLocator) {
+        const observationRows = adapter
+            .prepare(`
+          SELECT cm.case_id
+          FROM entity_observations eo
+          JOIN case_memberships cm
+            ON cm.source_type = 'observation'
+           AND cm.source_id = eo.id
+           AND cm.status = 'active'
+          WHERE eo.source_connector = ?
+            AND eo.source_locator = ?
+        `)
+            .all(sourceConnector, sourceLocator);
+        for (const row of observationRows) {
+            caseIds.add(row.case_id);
+        }
+    }
+    if (candidates.length > 0) {
+        const artifactRows = adapter
+            .prepare(`
+          SELECT case_id
+          FROM case_memberships
+          WHERE source_type = 'artifact'
+            AND status = 'active'
+            AND source_id IN (${placeholders(candidates)})
+        `)
+            .all(...candidates);
+        for (const row of artifactRows) {
+            caseIds.add(row.case_id);
+        }
+    }
+    return Array.from(caseIds).sort((left, right) => left.localeCompare(right));
+}
+function membershipCaseIdsForLeaf(adapter, leaf) {
+    if (leaf.source_type === 'connector_event') {
+        return listConnectorEventMembershipCaseIds(adapter, leaf);
+    }
+    return listActiveMembershipCaseIds(adapter, leaf.source_type, leaf.source_id);
+}
+function upsertOrphan(orphans, leaf) {
+    const key = sourceKey(leaf.source_type, leaf.source_id);
+    const existing = orphans.get(key);
+    if (existing && existing.score >= leaf.fused_rank_score) {
+        return;
+    }
+    const diagnostics = leafDiagnostics(leaf);
+    const contributingLeafDiagnostics = diagnostics ? { [leaf.source_id]: diagnostics } : undefined;
+    orphans.set(key, {
+        source_type: leaf.source_type === 'connector_event' ? 'standalone_connector_hit' : leaf.source_type,
+        source_id: leaf.source_id,
+        case_id: null,
+        score: leaf.fused_rank_score,
+        ...(diagnostics ? { retrieval_diagnostics: diagnostics } : {}),
+        ...(contributingLeafDiagnostics
+            ? { contributing_leaf_diagnostics: contributingLeafDiagnostics }
+            : {}),
+        record: leaf.record,
+    });
+}
+function upsertDirectCase(directCases, adapter, leaf, caseId) {
+    const survivorCaseId = canonicalCaseId(adapter, caseId);
+    const existing = directCases.get(survivorCaseId);
+    if (!existing || leaf.fused_rank_score > existing.score) {
+        directCases.set(survivorCaseId, {
+            case_id: survivorCaseId,
+            score: leaf.fused_rank_score,
+            max_leaf_score: leaf.fused_rank_score,
+            contributing_leaves: new Set([leaf.source_id]),
+            contributing_leaf_diagnostics: new Map(),
+            dedupe_keys: new Set([leaf.source_id]),
+            record: withCaseId(leaf.record, survivorCaseId),
+        });
+    }
+    const group = directCases.get(survivorCaseId);
+    if (group) {
+        attachLeafDiagnostics(group, leaf);
+    }
+    return survivorCaseId;
+}
+function upsertCaseGroup(groups, adapter, leaf, survivorCaseId) {
+    const dedupeKey = `${survivorCaseId}\0${leaf.source_type}\0${leaf.source_id}`;
+    let group = groups.get(survivorCaseId);
+    if (!group) {
+        group = {
+            case_id: survivorCaseId,
+            score: 0,
+            max_leaf_score: 0,
+            contributing_leaves: new Set(),
+            contributing_leaf_diagnostics: new Map(),
+            dedupe_keys: new Set(),
+            record: loadCaseRecord(adapter, survivorCaseId),
+        };
+        groups.set(survivorCaseId, group);
+    }
+    if (group.dedupe_keys.has(dedupeKey)) {
+        return;
+    }
+    group.dedupe_keys.add(dedupeKey);
+    group.contributing_leaves.add(leaf.source_id);
+    attachLeafDiagnostics(group, leaf);
+    group.score += leaf.fused_rank_score;
+    group.max_leaf_score = Math.max(group.max_leaf_score, leaf.fused_rank_score);
+}
+function groupToResult(group) {
+    const baseRecord = objectRecord(withCaseId(group.record, group.case_id)) ?? {
+        case_id: group.case_id,
+    };
+    const record = { ...baseRecord, max_leaf_score: group.max_leaf_score };
+    const contributingLeafDiagnostics = diagnosticsRecord(group.contributing_leaf_diagnostics);
+    return {
+        source_type: 'case',
+        source_id: group.case_id,
+        case_id: group.case_id,
+        score: group.score,
+        contributing_leaves: Array.from(group.contributing_leaves).sort((left, right) => left.localeCompare(right)),
+        ...(contributingLeafDiagnostics
+            ? { contributing_leaf_diagnostics: contributingLeafDiagnostics }
+            : {}),
+        ...(group.retrieval_diagnostics ? { retrieval_diagnostics: group.retrieval_diagnostics } : {}),
+        record,
+    };
+}
+function maxLeafScore(result) {
+    const object = objectRecord(result.record);
+    const value = object?.max_leaf_score;
+    return typeof value === 'number' && Number.isFinite(value) ? value : result.score;
+}
+function compareResults(left, right) {
+    if (right.score !== left.score) {
+        return right.score - left.score;
+    }
+    const leafDelta = maxLeafScore(right) - maxLeafScore(left);
+    if (leafDelta !== 0) {
+        return leafDelta;
+    }
+    if (left.source_type === 'case' && right.source_type !== 'case') {
+        return -1;
+    }
+    if (left.source_type !== 'case' && right.source_type === 'case') {
+        return 1;
+    }
+    return left.source_id.localeCompare(right.source_id);
+}
+function rollUpSearchHits(input) {
+    const directCases = new Map();
+    const directCaseIds = new Set();
+    const groupedCases = new Map();
+    const orphans = new Map();
+    for (const leaf of input.fusedHits) {
+        if (leaf.source_type === 'wiki_page' && leaf.page_type === 'case') {
+            if (leaf.case_id) {
+                const survivorCaseId = upsertDirectCase(directCases, input.adapter, leaf, leaf.case_id);
+                directCaseIds.add(survivorCaseId);
+                groupedCases.delete(survivorCaseId);
+            }
+            else {
+                upsertOrphan(orphans, leaf);
+            }
+            continue;
+        }
+        const membershipCaseIds = membershipCaseIdsForLeaf(input.adapter, leaf);
+        if (membershipCaseIds.length === 0) {
+            upsertOrphan(orphans, leaf);
+            continue;
+        }
+        for (const membershipCaseId of membershipCaseIds) {
+            const survivorCaseId = canonicalCaseId(input.adapter, membershipCaseId);
+            if (directCaseIds.has(survivorCaseId)) {
+                continue;
+            }
+            upsertCaseGroup(groupedCases, input.adapter, leaf, survivorCaseId);
+        }
+    }
+    return [
+        ...Array.from(directCases.values()).map(groupToResult),
+        ...Array.from(groupedCases.values())
+            .filter((group) => !directCaseIds.has(group.case_id))
+            .map(groupToResult),
+        ...Array.from(orphans.values()),
+    ].sort(compareResults);
+}
+//# sourceMappingURL=search-rollup.js.map

package/dist/cases/sqlite-transaction.d.ts

@@ -0,0 +1,10 @@
+export interface ImmediateTransactionAdapter {
+    exec?: (sql: string) => void;
+    transaction: <T>(fn: () => T) => T;
+}
+export interface ImmediateTransactionOptions {
+    maxBusyRetries?: number;
+    busyRetryDelayMs?: number;
+}
+export declare function runImmediateTransaction<T>(adapter: ImmediateTransactionAdapter, fn: () => T, options?: ImmediateTransactionOptions): T;
+//# sourceMappingURL=sqlite-transaction.d.ts.map

package/dist/cases/sqlite-transaction.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runImmediateTransaction = runImmediateTransaction;
+function isThenable(value) {
+    return (((typeof value === 'object' && value !== null) || typeof value === 'function') &&
+        typeof value.then === 'function');
+}
+function isBusyError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const code = error.code;
+    return code === 'SQLITE_BUSY' || /SQLITE_BUSY|database is locked/i.test(error.message);
+}
+function requireSynchronousResult(result) {
+    if (isThenable(result)) {
+        throw new Error('runImmediateTransaction() callbacks must be synchronous');
+    }
+    return result;
+}
+function runImmediateTransaction(adapter, fn, options) {
+    const maxBusyRetries = options?.maxBusyRetries ?? 3;
+    const busyRetryDelayMs = Math.max(0, options?.busyRetryDelayMs ?? 20);
+    if (!adapter.exec) {
+        // Fake test adapters without exec can only provide deferred transaction
+        // semantics; production SQLite adapters should expose exec for BEGIN IMMEDIATE.
+        return adapter.transaction(() => requireSynchronousResult(fn()));
+    }
+    let attempt = 0;
+    for (;;) {
+        try {
+            adapter.exec('BEGIN IMMEDIATE');
+            try {
+                const result = requireSynchronousResult(fn());
+                adapter.exec('COMMIT');
+                return result;
+            }
+            catch (error) {
+                try {
+                    adapter.exec('ROLLBACK');
+                }
+                catch {
+                    // Preserve the original transaction failure when rollback also fails.
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            if (isBusyError(error) && attempt < maxBusyRetries) {
+                attempt += 1;
+                if (busyRetryDelayMs > 0) {
+                    // Preserve the retry budget contract without blocking the event loop
+                    // inside shared core code. Callers that need delayed retries should
+                    // wrap this synchronous helper at a higher async boundary.
+                }
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=sqlite-transaction.js.map

package/dist/cases/store.d.ts

@@ -0,0 +1,74 @@
+import { type DatabaseAdapter } from '../db-manager.js';
+import type { CanonicalCaseResolution, CaseAssembly, CaseAssemblyMembership, CaseBlocker, CaseConfidence, CaseCorrectionRecord, CaseMembershipRecord, CaseMembershipSourceType, CasePrimaryActor, CaseProposalKind, CaseProposalQueueRecord, CaseTruthRecord } from './types.js';
+type CaseStoreAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export interface UpsertCaseTruthSlowFieldsInput {
+    case_id: string;
+    current_wiki_path?: string | null;
+    title: string;
+    status_reason?: string | null;
+    primary_actors?: CasePrimaryActor[] | string | null;
+    blockers?: CaseBlocker[] | string | null;
+    confidence?: CaseConfidence | null;
+    scope_refs?: Array<{
+        kind: string;
+        id: string;
+    }> | string | null;
+    wiki_path_history?: Array<{
+        path: string;
+        valid_from: string;
+        valid_to: string | null;
+    }> | string | null;
+    compiled_at: string;
+}
+export interface UpsertExplicitCaseMembershipsInput {
+    case_id: string;
+    rows: Array<{
+        source_type: CaseMembershipSourceType;
+        source_id: string;
+        role?: string | null;
+        confidence?: number | null;
+        reason?: string | null;
+    }>;
+}
+export interface EnqueueCaseProposalInput {
+    project: string;
+    proposal_kind: CaseProposalKind;
+    proposed_payload: string;
+    stable_fingerprint_input: unknown;
+    conflicting_case_id?: string | null;
+}
+export interface AssembleCaseOptions {
+    since?: string;
+    limit?: number;
+}
+export declare function resolveCanonicalCaseChain(adapter: CaseStoreAdapter, caseId: string, maxDepth?: number): CanonicalCaseResolution;
+export declare function expandCaseChainForAssembly(adapter: Pick<DatabaseAdapter, 'prepare'>, terminalCaseId: string, resolvedChain: string[]): string[];
+export declare function upsertCaseTruthSlowFields(input: UpsertCaseTruthSlowFieldsInput): CaseTruthRecord;
+export declare function upsertCaseTruthSlowFields(adapter: CaseStoreAdapter, input: UpsertCaseTruthSlowFieldsInput): CaseTruthRecord;
+export declare function upsertExplicitCaseMemberships(input: UpsertExplicitCaseMembershipsInput): CaseMembershipRecord[];
+export declare function upsertExplicitCaseMemberships(adapter: CaseStoreAdapter, input: UpsertExplicitCaseMembershipsInput): CaseMembershipRecord[];
+export declare function listActiveMembershipsForCaseChain(adapter: CaseStoreAdapter, caseIds: string[], limit?: number): CaseAssemblyMembership[];
+export interface ListActiveCorrectionsForCaseResult {
+    terminal_case_id: string;
+    resolved_via_case_id: string | null;
+    chain: string[];
+    corrections: CaseCorrectionRecord[];
+}
+/**
+ * Resolves the canonical merge chain for caseId (both up to terminal and
+ * down to merged losers) and returns every active, unreverted correction
+ * across the entire chain. HITL surfaces must use this rather than a
+ * direct `WHERE case_id = ?` query so post-merge corrections on loser
+ * cases remain visible and actionable from the survivor's view.
+ */
+export declare function listActiveCorrectionsForCase(adapter: CaseStoreAdapter, caseId: string): ListActiveCorrectionsForCaseResult;
+export declare function listActiveCorrectionsForCaseChain(adapter: CaseStoreAdapter, caseIds: string[]): CaseCorrectionRecord[];
+export declare function enqueueCaseProposal(adapter: CaseStoreAdapter, input: EnqueueCaseProposalInput): {
+    proposal_id: string;
+    inserted: boolean;
+};
+export declare function listUnresolvedCaseProposals(adapter: CaseStoreAdapter, project: string): CaseProposalQueueRecord[];
+export declare function assembleCase(caseId: string, options?: AssembleCaseOptions): CaseAssembly;
+export declare function assembleCase(adapter: CaseStoreAdapter, caseId: string, options?: AssembleCaseOptions): CaseAssembly;
+export {};
+//# sourceMappingURL=store.d.ts.map