@jungjaehoon/mama-core 1.4.1 → 1.5.0

package/dist/entities/candidate-generator.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENTITY_EMBEDDING_TOPN = void 0;
+exports.dedupeObservationsBySource = dedupeObservationsBySource;
+exports.generateResolutionCandidates = generateResolutionCandidates;
+const errors_js_1 = require("./errors.js");
+const normalization_js_1 = require("./normalization.js");
+exports.ENTITY_EMBEDDING_TOPN = 50;
+const CROSS_SCOPE_PROBE_MIN_EMBEDDING_SCORE = 0.84;
+const MAX_DETERMINISTIC_SCOPE_BUCKET = 32;
+const MAX_CROSS_SCOPE_SCOPE_BUCKET = 8;
+function tokenize(input) {
+    return input
+        .toLowerCase()
+        .split(/[\s,.!?;:()[\]{}"'/_-]+/u)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 1);
+}
+function contextScore(left, right) {
+    const leftTokens = new Set(tokenize(left.context_summary ?? ''));
+    const rightTokens = new Set(tokenize(right.context_summary ?? ''));
+    if (leftTokens.size === 0 || rightTokens.size === 0) {
+        return 0;
+    }
+    let overlap = 0;
+    for (const token of leftTokens) {
+        if (rightTokens.has(token)) {
+            overlap += 1;
+        }
+    }
+    return overlap / Math.max(Math.min(leftTokens.size, rightTokens.size), 1);
+}
+function structuralScore(left, right) {
+    if (left.normalized_form === right.normalized_form) {
+        return 1;
+    }
+    const leftIds = (0, normalization_js_1.extractStructuredIdentifiers)(left.surface_form);
+    const rightIds = (0, normalization_js_1.extractStructuredIdentifiers)(right.surface_form);
+    const hasSharedEmail = leftIds.emails.some((value) => rightIds.emails.includes(value));
+    const hasSharedHandle = leftIds.handles.some((value) => rightIds.handles.includes(value));
+    const hasSharedDomain = leftIds.domains.some((value) => rightIds.domains.includes(value));
+    if (hasSharedEmail || hasSharedHandle || hasSharedDomain) {
+        return 0.75;
+    }
+    return 0;
+}
+function stringScore(left, right) {
+    if (left.normalized_form === right.normalized_form) {
+        return 1;
+    }
+    const leftText = left.surface_form.toLowerCase();
+    const rightText = right.surface_form.toLowerCase();
+    const sharedPrefix = leftText.length > 0 && rightText.length > 0 && leftText[0] === rightText[0];
+    return sharedPrefix ? 0.1 : 0;
+}
+function scorePair(left, right, probeKind) {
+    const score_structural = structuralScore(left, right);
+    const score_string = stringScore(left, right);
+    const score_context = contextScore(left, right);
+    const score_graph = 0;
+    const score_total = score_structural + score_string + score_context + score_graph;
+    return {
+        left,
+        right,
+        score_structural,
+        score_string,
+        score_context,
+        score_graph,
+        score_total,
+        probe_kind: probeKind,
+    };
+}
+function shouldConsiderPair(left, right) {
+    if (left.entity_kind_hint &&
+        right.entity_kind_hint &&
+        left.entity_kind_hint !== right.entity_kind_hint) {
+        return false;
+    }
+    if (left.scope_kind !== right.scope_kind) {
+        return false;
+    }
+    if (left.scope_id !== right.scope_id) {
+        return false;
+    }
+    return true;
+}
+function shouldConsiderCrossScopeProbe(left, right) {
+    if (!left.entity_kind_hint ||
+        !right.entity_kind_hint ||
+        left.entity_kind_hint !== right.entity_kind_hint) {
+        return false;
+    }
+    if (left.observation_type !== right.observation_type) {
+        return false;
+    }
+    if (left.scope_kind !== right.scope_kind) {
+        return false;
+    }
+    if (left.scope_id === right.scope_id) {
+        return false;
+    }
+    return true;
+}
+function buildBlockKeys(observation) {
+    const keys = new Set();
+    keys.add(`norm:${observation.normalized_form}`);
+    for (const related of observation.related_surface_forms) {
+        keys.add(`related:${related}`);
+    }
+    const ids = (0, normalization_js_1.extractStructuredIdentifiers)(observation.surface_form);
+    for (const email of ids.emails) {
+        keys.add(`email:${email}`);
+    }
+    for (const handle of ids.handles) {
+        keys.add(`handle:${handle}`);
+    }
+    for (const domain of ids.domains) {
+        keys.add(`domain:${domain}`);
+    }
+    const contextTokens = tokenize(observation.context_summary ?? '').slice(0, 3);
+    for (const token of contextTokens) {
+        keys.add(`ctx:${observation.scope_kind}:${observation.scope_id ?? 'global'}:${token}`);
+    }
+    return Array.from(keys);
+}
+function normalizeSurfaceForm(value) {
+    if (value.trim().length === 0) {
+        return '';
+    }
+    return (0, normalization_js_1.normalizeEntityLabel)(value).normalized;
+}
+function sharedNormalizedRelatedCount(left, right) {
+    const leftRelated = new Set(left.related_surface_forms.map((value) => normalizeSurfaceForm(value)));
+    const rightRelated = new Set(right.related_surface_forms.map((value) => normalizeSurfaceForm(value)));
+    if (leftRelated.size === 0 || rightRelated.size === 0) {
+        return 0;
+    }
+    let overlap = 0;
+    for (const related of leftRelated) {
+        if (rightRelated.has(related)) {
+            overlap += 1;
+        }
+    }
+    return overlap;
+}
+function getTimestampDistance(left, right) {
+    if (left.timestamp_observed === null || right.timestamp_observed === null) {
+        return Number.POSITIVE_INFINITY;
+    }
+    return Math.abs(left.timestamp_observed - right.timestamp_observed);
+}
+function buildPairKey(left, right) {
+    return `${left.id}::${right.id}`;
+}
+function compareObservationForSampling(left, right) {
+    const leftRelated = left.related_surface_forms.length;
+    const rightRelated = right.related_surface_forms.length;
+    if (rightRelated !== leftRelated) {
+        return rightRelated - leftRelated;
+    }
+    const leftContext = left.context_summary?.length ?? 0;
+    const rightContext = right.context_summary?.length ?? 0;
+    if (rightContext !== leftContext) {
+        return rightContext - leftContext;
+    }
+    const leftObserved = left.timestamp_observed ?? Number.NEGATIVE_INFINITY;
+    const rightObserved = right.timestamp_observed ?? Number.NEGATIVE_INFINITY;
+    if (rightObserved !== leftObserved) {
+        return rightObserved - leftObserved;
+    }
+    return left.id.localeCompare(right.id);
+}
+function capObservationGroup(observations, limit) {
+    if (observations.length <= limit) {
+        return observations;
+    }
+    return [...observations].sort(compareObservationForSampling).slice(0, limit);
+}
+function pushTopProbe(probes, candidate, maxPairs) {
+    probes.push(candidate);
+    probes.sort(compareProbePairs);
+    if (probes.length > maxPairs) {
+        probes.length = maxPairs;
+    }
+}
+function buildCrossLanguageFamilyKey(left, right) {
+    if (!left.lang || !right.lang || left.lang === right.lang) {
+        return null;
+    }
+    const forms = [
+        `${left.lang}:${left.normalized_form}`,
+        `${right.lang}:${right.normalized_form}`,
+    ].sort();
+    const observationTypes = [left.observation_type, right.observation_type].sort();
+    return JSON.stringify([
+        left.entity_kind_hint ?? right.entity_kind_hint ?? 'unknown',
+        observationTypes,
+        forms,
+    ]);
+}
+function compareProbePairs(left, right) {
+    const relatedDelta = sharedNormalizedRelatedCount(right.left, right.right) -
+        sharedNormalizedRelatedCount(left.left, left.right);
+    if (relatedDelta !== 0) {
+        return relatedDelta;
+    }
+    if (right.score_total !== left.score_total) {
+        return right.score_total - left.score_total;
+    }
+    const timestampDelta = getTimestampDistance(left.left, left.right) - getTimestampDistance(right.left, right.right);
+    if (timestampDelta !== 0) {
+        return timestampDelta;
+    }
+    return buildPairKey(left.left, left.right).localeCompare(buildPairKey(right.left, right.right));
+}
+function dedupeCrossLanguageFamilies(candidates, observationLookup) {
+    const deduped = [];
+    const bestByFamily = new Map();
+    for (const candidate of candidates) {
+        const left = observationLookup.get(candidate.left_ref);
+        const right = observationLookup.get(candidate.right_ref);
+        if (!left || !right) {
+            deduped.push(candidate);
+            continue;
+        }
+        const familyKey = buildCrossLanguageFamilyKey(left, right);
+        if (!familyKey) {
+            deduped.push(candidate);
+            continue;
+        }
+        const existing = bestByFamily.get(familyKey);
+        if (!existing ||
+            candidate.score_total > existing.score_total ||
+            (candidate.score_total === existing.score_total &&
+                candidate.id.localeCompare(existing.id) < 0)) {
+            bestByFamily.set(familyKey, candidate);
+        }
+    }
+    return deduped.concat(Array.from(bestByFamily.values()));
+}
+function buildCrossScopeProbePairs(observations, seenPairs, maxPairs) {
+    if (maxPairs <= 0) {
+        return [];
+    }
+    const probes = [];
+    const bucketMap = new Map();
+    for (const observation of observations) {
+        if (!observation.entity_kind_hint) {
+            continue;
+        }
+        const bucketKey = JSON.stringify([
+            observation.entity_kind_hint,
+            observation.observation_type,
+            observation.scope_kind,
+        ]);
+        const bucket = bucketMap.get(bucketKey) ?? [];
+        bucket.push(observation);
+        bucketMap.set(bucketKey, bucket);
+    }
+    for (const bucket of bucketMap.values()) {
+        const scopeBuckets = new Map();
+        for (const observation of bucket) {
+            const scopeKey = observation.scope_id ?? 'global';
+            const scopeBucket = scopeBuckets.get(scopeKey) ?? [];
+            scopeBucket.push(observation);
+            scopeBuckets.set(scopeKey, scopeBucket);
+        }
+        const limitedScopeBuckets = Array.from(scopeBuckets.values())
+            .filter((scopeBucket) => scopeBucket.length > 0)
+            .map((scopeBucket) => capObservationGroup(scopeBucket, MAX_CROSS_SCOPE_SCOPE_BUCKET));
+        for (let i = 0; i < limitedScopeBuckets.length; i += 1) {
+            for (let j = i + 1; j < limitedScopeBuckets.length; j += 1) {
+                const leftBucket = limitedScopeBuckets[i];
+                const rightBucket = limitedScopeBuckets[j];
+                for (const first of leftBucket) {
+                    for (const second of rightBucket) {
+                        const [left, right] = first.id.localeCompare(second.id) <= 0 ? [first, second] : [second, first];
+                        const pairKey = buildPairKey(left, right);
+                        if (seenPairs.has(pairKey)) {
+                            continue;
+                        }
+                        if (!shouldConsiderCrossScopeProbe(left, right)) {
+                            continue;
+                        }
+                        seenPairs.add(pairKey);
+                        pushTopProbe(probes, scorePair(left, right, 'cross_scope'), maxPairs);
+                    }
+                }
+            }
+        }
+    }
+    return probes;
+}
+function hasMultipleScopes(observations) {
+    const scopes = new Set(observations.map((observation) => `${observation.scope_kind}:${observation.scope_id ?? 'global'}`));
+    return scopes.size > 1;
+}
+function dedupeObservationsBySource(observations) {
+    const seen = new Set();
+    const deduped = [];
+    for (const observation of observations) {
+        const key = JSON.stringify([
+            observation.source_connector,
+            observation.source_locator ?? `missing-locator:${observation.id}`,
+            observation.source_raw_record_id,
+            observation.observation_type,
+        ]);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(observation);
+    }
+    return deduped;
+}
+async function generateResolutionCandidates(observations, options = {}) {
+    const deduped = dedupeObservationsBySource(observations);
+    const observationLookup = new Map(deduped.map((observation) => [observation.id, observation]));
+    const blockMap = new Map();
+    for (const observation of deduped) {
+        const keys = buildBlockKeys(observation);
+        for (const key of keys) {
+            const existing = blockMap.get(key) ?? [];
+            existing.push(observation);
+            blockMap.set(key, existing);
+        }
+    }
+    const preliminary = [];
+    const seenPairs = new Set();
+    for (const bucket of blockMap.values()) {
+        if (bucket.length < 2) {
+            continue;
+        }
+        const scopeBuckets = new Map();
+        for (const observation of bucket) {
+            const scopeKey = `${observation.scope_kind}:${observation.scope_id ?? 'global'}`;
+            const scopeBucket = scopeBuckets.get(scopeKey) ?? [];
+            scopeBucket.push(observation);
+            scopeBuckets.set(scopeKey, scopeBucket);
+        }
+        for (const scopeBucket of scopeBuckets.values()) {
+            const limitedBucket = capObservationGroup(scopeBucket, MAX_DETERMINISTIC_SCOPE_BUCKET);
+            if (limitedBucket.length < 2) {
+                continue;
+            }
+            for (let i = 0; i < limitedBucket.length; i += 1) {
+                for (let j = i + 1; j < limitedBucket.length; j += 1) {
+                    const first = limitedBucket[i];
+                    const second = limitedBucket[j];
+                    const [left, right] = first.id.localeCompare(second.id) <= 0 ? [first, second] : [second, first];
+                    const pairKey = `${left.id}::${right.id}`;
+                    if (seenPairs.has(pairKey)) {
+                        continue;
+                    }
+                    if (!shouldConsiderPair(left, right)) {
+                        continue;
+                    }
+                    seenPairs.add(pairKey);
+                    const scored = scorePair(left, right, 'deterministic');
+                    if (scored.score_total <= 0 && !options.embeddingScorer) {
+                        continue;
+                    }
+                    preliminary.push(scored);
+                }
+            }
+        }
+    }
+    preliminary.sort((left, right) => right.score_total - left.score_total);
+    const topNLimit = options.topN ?? exports.ENTITY_EMBEDDING_TOPN;
+    const topN = preliminary.slice(0, topNLimit);
+    topN.sort((left, right) => right.score_total - left.score_total);
+    const pairBudget = Math.ceil(topNLimit ** 2 / 2);
+    const crossScopeBudget = options.embeddingScorer ? Math.max(0, pairBudget - topN.length) : 0;
+    const crossScopePairs = options.embeddingScorer && crossScopeBudget > 0 && hasMultipleScopes(deduped)
+        ? buildCrossScopeProbePairs(deduped, seenPairs, crossScopeBudget)
+        : [];
+    const candidates = [];
+    for (const item of [...topN, ...crossScopePairs]) {
+        let score_embedding = 0;
+        if (options.embeddingScorer) {
+            try {
+                score_embedding = await options.embeddingScorer(item.left, item.right);
+            }
+            catch (error) {
+                if (error instanceof errors_js_1.EmbeddingUnavailableError) {
+                    throw error;
+                }
+                throw new errors_js_1.EmbeddingUnavailableError({
+                    reason: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        const finalScore = item.score_total + score_embedding;
+        if (finalScore <= 0) {
+            continue;
+        }
+        if (item.probe_kind === 'cross_scope' &&
+            score_embedding < CROSS_SCOPE_PROBE_MIN_EMBEDDING_SCORE) {
+            continue;
+        }
+        const createdAt = Date.now();
+        candidates.push({
+            id: `candidate_${item.left.id}_${item.right.id}`,
+            candidate_kind: 'cluster',
+            left_ref: item.left.id,
+            right_ref: item.right.id,
+            status: 'pending',
+            score_total: finalScore,
+            score_structural: item.score_structural,
+            score_string: item.score_string,
+            score_context: item.score_context,
+            score_graph: item.score_graph,
+            score_embedding,
+            rule_trace: JSON.stringify({
+                structural: item.score_structural,
+                string: item.score_string,
+                context: item.score_context,
+            }),
+            extractor_version: item.left.extractor_version,
+            embedding_model_version: item.left.embedding_model_version ?? item.right.embedding_model_version,
+            created_at: createdAt,
+            updated_at: createdAt,
+        });
+    }
+    const dedupedFamilies = options.embeddingScorer
+        ? dedupeCrossLanguageFamilies(candidates, observationLookup)
+        : candidates;
+    dedupedFamilies.sort((left, right) => {
+        if (right.score_total !== left.score_total) {
+            return right.score_total - left.score_total;
+        }
+        return left.id.localeCompare(right.id);
+    });
+    return dedupedFamilies.slice(0, topNLimit);
+}
+//# sourceMappingURL=candidate-generator.js.map

package/dist/entities/entity-impact.d.ts

@@ -0,0 +1,41 @@
+import { type SourceLocatorKind } from './source-locator.js';
+import type { EntityIngestRun, EntityLineageLink, EntityNode } from './types.js';
+interface InspectorDetail {
+    entity: EntityNode;
+    history_incomplete: boolean;
+}
+interface InspectorLineageRow extends EntityLineageLink {
+    source_connector: string;
+    source_raw_record_id: string;
+    source_locator: string | null;
+    source_locator_kind: SourceLocatorKind;
+    surface_form: string;
+}
+interface InspectorLineageResult {
+    rows: InspectorLineageRow[];
+    history_incomplete: boolean;
+}
+interface ImpactMemoryRow {
+    id: string;
+    topic: string;
+    summary: string;
+    created_at: number;
+}
+interface ImpactAuditRunRow {
+    id: string;
+    classification: string | null;
+    status: string;
+    created_at: number;
+    completed_at: number | null;
+}
+interface EntityImpactResult {
+    related_memories: ImpactMemoryRow[];
+    ingest_runs: EntityIngestRun[];
+    audit_runs: ImpactAuditRunRow[];
+}
+export declare function getEntityInspectorDetail(entityId: string): Promise<InspectorDetail>;
+export declare function listEntityLineageForInspector(entityId: string, limit?: number): Promise<InspectorLineageResult>;
+export declare function getEntityImpact(entityId: string): Promise<EntityImpactResult>;
+export declare function getEntityIngestRun(runId: string): Promise<EntityIngestRun | null>;
+export {};
+//# sourceMappingURL=entity-impact.d.ts.map

package/dist/entities/entity-impact.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntityInspectorDetail = getEntityInspectorDetail;
+exports.listEntityLineageForInspector = listEntityLineageForInspector;
+exports.getEntityImpact = getEntityImpact;
+exports.getEntityIngestRun = getEntityIngestRun;
+const db_manager_js_1 = require("../db-manager.js");
+const source_locator_js_1 = require("./source-locator.js");
+const lineage_store_js_1 = require("./lineage-store.js");
+function mapEntityNode(row) {
+    return {
+        id: String(row.id),
+        kind: row.kind,
+        preferred_label: String(row.preferred_label),
+        status: row.status,
+        scope_kind: typeof row.scope_kind === 'string' ? row.scope_kind : null,
+        scope_id: typeof row.scope_id === 'string' ? row.scope_id : null,
+        merged_into: typeof row.merged_into === 'string' ? row.merged_into : null,
+        created_at: Number(row.created_at),
+        updated_at: Number(row.updated_at),
+    };
+}
+async function getEntityInspectorDetail(entityId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter.prepare(`SELECT * FROM entity_nodes WHERE id = ?`).get(entityId);
+    if (!row) {
+        throw new Error(`Entity not found: ${entityId}`);
+    }
+    const lineageCount = adapter
+        .prepare(`
+        SELECT COUNT(*) AS total
+        FROM entity_lineage_links
+        WHERE canonical_entity_id = ?
+          AND status = 'active'
+      `)
+        .get(entityId);
+    return {
+        entity: mapEntityNode(row),
+        history_incomplete: lineageCount.total === 0,
+    };
+}
+async function listEntityLineageForInspector(entityId, limit = 50) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const safeLimit = Math.max(1, Math.min(limit, 500));
+    const rows = adapter
+        .prepare(`
+        SELECT
+          l.*,
+          o.source_connector,
+          o.source_raw_record_id,
+          o.source_locator,
+          o.surface_form
+        FROM entity_lineage_links l
+        JOIN entity_observations o ON o.id = l.entity_observation_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY l.created_at ASC
+        LIMIT ?
+      `)
+        .all(entityId, safeLimit);
+    return {
+        rows: rows.map((row) => ({
+            id: String(row.id),
+            canonical_entity_id: String(row.canonical_entity_id),
+            entity_observation_id: String(row.entity_observation_id),
+            source_entity_id: typeof row.source_entity_id === 'string' ? row.source_entity_id : null,
+            contribution_kind: row.contribution_kind,
+            run_id: typeof row.run_id === 'string' ? row.run_id : null,
+            candidate_id: typeof row.candidate_id === 'string' ? row.candidate_id : null,
+            review_action_id: typeof row.review_action_id === 'string' ? row.review_action_id : null,
+            status: row.status,
+            capture_mode: row.capture_mode,
+            confidence: Number(row.confidence),
+            created_at: Number(row.created_at),
+            superseded_at: typeof row.superseded_at === 'number' ? row.superseded_at : null,
+            source_connector: String(row.source_connector),
+            source_raw_record_id: String(row.source_raw_record_id),
+            source_locator: typeof row.source_locator === 'string' ? row.source_locator : null,
+            source_locator_kind: (0, source_locator_js_1.detectSourceLocatorKind)(typeof row.source_locator === 'string' ? row.source_locator : null),
+            surface_form: String(row.surface_form),
+        })),
+        history_incomplete: rows.length === 0,
+    };
+}
+async function getEntityImpact(entityId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const relatedMemories = adapter
+        .prepare(`
+        SELECT DISTINCT d.id, d.topic, d.summary, d.created_at
+        FROM entity_lineage_links l
+        JOIN decision_entity_sources des ON des.entity_observation_id = l.entity_observation_id
+        JOIN decisions d ON d.id = des.decision_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY d.created_at DESC
+      `)
+        .all(entityId);
+    const ingestRuns = adapter
+        .prepare(`
+        SELECT DISTINCT ir.*
+        FROM entity_lineage_links l
+        JOIN entity_ingest_runs ir ON ir.id = l.run_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY ir.created_at DESC
+      `)
+        .all(entityId);
+    const auditRuns = adapter
+        .prepare(`
+        SELECT DISTINCT ar.id, ar.classification, ar.status, ar.created_at, ar.completed_at
+        FROM entity_lineage_links l
+        JOIN entity_ingest_runs ir ON ir.id = l.run_id
+        JOIN entity_audit_runs ar ON ar.id = ir.audit_run_id
+        WHERE l.canonical_entity_id = ?
+          AND l.status = 'active'
+        ORDER BY ar.created_at DESC
+        LIMIT 10
+      `)
+        .all(entityId);
+    return {
+        related_memories: relatedMemories.map((row) => ({
+            id: row.id,
+            topic: row.topic,
+            summary: row.summary ?? row.topic,
+            created_at: row.created_at,
+        })),
+        ingest_runs: ingestRuns.map(lineage_store_js_1.parseEntityIngestRunRow),
+        audit_runs: auditRuns,
+    };
+}
+async function getEntityIngestRun(runId) {
+    await (0, db_manager_js_1.initDB)();
+    const adapter = (0, db_manager_js_1.getAdapter)();
+    const row = adapter.prepare(`SELECT * FROM entity_ingest_runs WHERE id = ?`).get(runId);
+    return row ? (0, lineage_store_js_1.parseEntityIngestRunRow)(row) : null;
+}
+//# sourceMappingURL=entity-impact.js.map

package/dist/entities/entity-linked-decision-counts.d.ts

@@ -0,0 +1,2 @@
+export function loadLinkedDecisionCounts(adapter: any, entityIds: any): Map<any, any>;
+//# sourceMappingURL=entity-linked-decision-counts.d.ts.map

package/dist/entities/entity-linked-decision-counts.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadLinkedDecisionCounts = loadLinkedDecisionCounts;
+function loadLinkedDecisionCounts(adapter, entityIds) {
+    const uniqueIds = Array.from(new Set(entityIds.filter((entityId) => typeof entityId === 'string' && entityId.length > 0)));
+    if (uniqueIds.length === 0) {
+        return new Map();
+    }
+    const placeholders = uniqueIds.map(() => '?').join(', ');
+    const rows = adapter
+        .prepare(`
+        SELECT
+          l.canonical_entity_id AS entity_id,
+          COUNT(DISTINCT des.decision_id) AS linked_decision_count
+        FROM entity_lineage_links l
+        INNER JOIN decision_entity_sources des
+          ON des.entity_observation_id = l.entity_observation_id
+        WHERE l.status = 'active'
+          AND l.canonical_entity_id IN (${placeholders})
+        GROUP BY l.canonical_entity_id
+      `)
+        .all(...uniqueIds);
+    const counts = new Map(uniqueIds.map((entityId) => [entityId, 0]));
+    for (const row of rows) {
+        counts.set(row.entity_id, Number(row.linked_decision_count) || 0);
+    }
+    return counts;
+}
+//# sourceMappingURL=entity-linked-decision-counts.js.map

package/dist/entities/entity-list.d.ts

@@ -0,0 +1,23 @@
+import type { EntityNode } from './types.js';
+export interface ListCanonicalEntitiesInput {
+    limit: number;
+    cursor?: string | null;
+    include_noisy?: boolean;
+}
+export interface CanonicalEntityListRow {
+    id: string;
+    kind: EntityNode['kind'];
+    preferred_label: string;
+    scope_kind: EntityNode['scope_kind'];
+    scope_id: string | null;
+    created_at: number;
+    linked_decision_count: number;
+}
+export interface ListCanonicalEntitiesResult {
+    entities: CanonicalEntityListRow[];
+    next_cursor: string | null;
+    total_count: number;
+    visible_count: number;
+}
+export declare function listCanonicalEntities(input: ListCanonicalEntitiesInput): Promise<ListCanonicalEntitiesResult>;
+//# sourceMappingURL=entity-list.d.ts.map