@jungjaehoon/mama-core 2.4.1 → 4.1.0

package/dist/agent-graph/graph-query.js

@@ -1,360 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGraphNeighborhood = getGraphNeighborhood;
-exports.getGraphPaths = getGraphPaths;
-exports.getGraphTimeline = getGraphTimeline;
-const ref_validation_js_1 = require("../edges/ref-validation.js");
-const store_js_1 = require("../entities/store.js");
-const errors_js_1 = require("./errors.js");
-const DEFAULT_GRAPH_LIMIT = 100;
-const DEFAULT_PATH_LIMIT = 10;
-const MAX_DEPTH = 5;
-function refKey(ref) {
-    return `${ref.kind}:${ref.id}`;
-}
-function edgeKey(edge) {
-    return edge.edge_id;
-}
-function eventKey(event) {
-    if (event.kind === 'edge') {
-        return event.edge.edge_id;
-    }
-    return `${event.ref.kind}:${event.ref.id}`;
-}
-function eventKindRank(kind) {
-    if (kind === 'entity') {
-        return 0;
-    }
-    if (kind === 'memory') {
-        return 1;
-    }
-    if (kind === 'raw') {
-        return 2;
-    }
-    if (kind === 'case') {
-        return 3;
-    }
-    return 4;
-}
-function normalizeDepth(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        return fallback;
-    }
-    return Math.max(0, Math.min(MAX_DEPTH, Math.floor(value)));
-}
-function normalizeLimit(value, fallback) {
-    if (typeof value !== 'number' || !Number.isFinite(value)) {
-        return fallback;
-    }
-    return Math.max(1, Math.floor(value));
-}
-function addNode(nodes, seen, ref) {
-    const key = refKey(ref);
-    if (!seen.has(key)) {
-        seen.add(key);
-        nodes.push(ref);
-    }
-}
-function addRef(refs, seen, ref) {
-    if (ref.kind === 'edge' || ref.kind === 'report') {
-        return;
-    }
-    const key = refKey(ref);
-    if (!seen.has(key)) {
-        seen.add(key);
-        refs.push(ref);
-    }
-}
-function oppositeRef(edge, current) {
-    const currentKey = refKey(current);
-    const refs = [];
-    if (refKey(edge.subject_ref) !== currentKey) {
-        refs.push(edge.subject_ref);
-    }
-    if (refKey(edge.object_ref) !== currentKey) {
-        refs.push(edge.object_ref);
-    }
-    if (refs.length === 0) {
-        refs.push(edge.object_ref);
-    }
-    return refs;
-}
-function listFilteredEdges(adapter, refs, input) {
-    // Spread, not a field-by-field re-listing. Re-listing is how the channel grant was
-    // silently dropped here while every other path enforced it: a new field on the
-    // visibility type simply never arrived, and nothing failed to say so.
-    return (0, ref_validation_js_1.listVisibleTwinEdgesForRefs)(adapter, refs, {
-        ...input.visibility,
-        edgeTypes: input.edge_filters?.edge_types,
-        asOfMs: input.as_of_ms,
-        limit: input.limit,
-    });
-}
-function assertRefsVisible(adapter, refs, visibility, asOfMs) {
-    try {
-        (0, ref_validation_js_1.assertTwinRefsVisible)(adapter, refs, { ...visibility, asOfMs });
-    }
-    catch (error) {
-        throw new errors_js_1.AgentGraphValidationError(error instanceof Error ? error.message : String(error));
-    }
-}
-function graphVisibility(input) {
-    return {
-        scopes: input.scopes,
-        connectors: input.connectors,
-        projectRefs: input.project_refs,
-        tenantId: input.tenant_id,
-        ...(input.channels ? { channels: input.channels } : {}),
-    };
-}
-function numberMs(value, field, refId) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return Math.floor(value);
-    }
-    throw new Error(`Invalid ${field} timestamp for graph timeline ref ${refId}.`);
-}
-function nullableNumberMs(value, field, refId) {
-    if (value === null || value === undefined) {
-        return null;
-    }
-    return numberMs(value, field, refId);
-}
-function parseTimestampMs(value, field, refId) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return Math.floor(value);
-    }
-    if (typeof value === 'string') {
-        const parsed = Date.parse(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-    throw new Error(`Invalid ${field} timestamp for graph timeline ref ${refId}.`);
-}
-function timelineWindow(input) {
-    const upperBounds = [input.to_ms, input.as_of_ms].filter((value) => typeof value === 'number');
-    return {
-        fromMs: input.from_ms,
-        toMs: upperBounds.length > 0 ? Math.min(...upperBounds) : undefined,
-    };
-}
-function isInTimelineWindow(atMs, window) {
-    return ((window.fromMs === undefined || atMs >= window.fromMs) &&
-        (window.toMs === undefined || atMs <= window.toMs));
-}
-function loadTimelineRecordEvent(adapter, ref) {
-    if (ref.kind === 'entity') {
-        const entity = (0, store_js_1.getEntityNode)(ref.id, adapter);
-        if (!entity || entity.status !== 'active') {
-            return null;
-        }
-        return { kind: 'entity', at_ms: entity.created_at, ref, entity };
-    }
-    if (ref.kind === 'memory') {
-        const row = adapter
-            .prepare(`
-          SELECT id, topic, decision, created_at, event_datetime
-          FROM decisions
-          WHERE id = ?
-          LIMIT 1
-        `)
-            .get(ref.id);
-        if (!row) {
-            return null;
-        }
-        const eventDatetime = nullableNumberMs(row.event_datetime, 'decisions.event_datetime', ref.id);
-        const createdAt = numberMs(row.created_at, 'decisions.created_at', ref.id);
-        return {
-            kind: 'memory',
-            at_ms: eventDatetime ?? createdAt,
-            ref,
-            memory: {
-                id: row.id,
-                topic: row.topic,
-                decision: row.decision,
-                created_at: createdAt,
-                event_datetime: eventDatetime,
-            },
-        };
-    }
-    if (ref.kind === 'raw') {
-        const row = adapter
-            .prepare(`
-          SELECT
-            event_index_id, source_connector, source_type, source_id, source_locator,
-            title, event_datetime, source_timestamp_ms
-          FROM connector_event_index
-          WHERE event_index_id = ?
-          LIMIT 1
-        `)
-            .get(ref.id);
-        if (!row) {
-            return null;
-        }
-        const eventDatetime = nullableNumberMs(row.event_datetime, 'connector_event_index.event_datetime', ref.id);
-        const sourceTimestampMs = numberMs(row.source_timestamp_ms, 'connector_event_index.source_timestamp_ms', ref.id);
-        return {
-            kind: 'raw',
-            at_ms: eventDatetime ?? sourceTimestampMs,
-            ref,
-            raw: {
-                event_index_id: row.event_index_id,
-                source_connector: row.source_connector,
-                source_type: row.source_type,
-                source_id: row.source_id,
-                source_locator: row.source_locator,
-                title: row.title,
-                event_datetime: eventDatetime,
-                source_timestamp_ms: sourceTimestampMs,
-            },
-        };
-    }
-    if (ref.kind === 'case') {
-        const row = adapter
-            .prepare(`
-          SELECT case_id, title, status, last_activity_at, created_at, updated_at
-          FROM case_truth
-          WHERE case_id = ?
-          LIMIT 1
-        `)
-            .get(ref.id);
-        if (!row) {
-            return null;
-        }
-        return {
-            kind: 'case',
-            at_ms: parseTimestampMs(row.last_activity_at ?? row.updated_at, 'case_truth.updated_at', ref.id),
-            ref,
-            case: {
-                case_id: row.case_id,
-                title: row.title,
-                status: row.status,
-                created_at: row.created_at,
-                updated_at: row.updated_at,
-                last_activity_at: row.last_activity_at,
-            },
-        };
-    }
-    return null;
-}
-function getGraphNeighborhood(adapter, input) {
-    const depth = normalizeDepth(input.depth, 1);
-    const limit = normalizeLimit(input.limit, DEFAULT_GRAPH_LIMIT);
-    const visibility = graphVisibility(input);
-    assertRefsVisible(adapter, [input.ref], visibility, input.as_of_ms);
-    const nodes = [];
-    const edges = [];
-    const seenNodes = new Set();
-    const seenEdges = new Set();
-    addNode(nodes, seenNodes, input.ref);
-    let frontier = [input.ref];
-    for (let currentDepth = 0; currentDepth < depth && frontier.length > 0; currentDepth++) {
-        const found = listFilteredEdges(adapter, frontier, {
-            visibility,
-            edge_filters: input.edge_filters,
-            as_of_ms: input.as_of_ms,
-            limit,
-        });
-        const nextFrontier = [];
-        const nextKeys = new Set();
-        for (const edge of found) {
-            if (seenEdges.size >= limit) {
-                break;
-            }
-            if (!seenEdges.has(edgeKey(edge))) {
-                seenEdges.add(edgeKey(edge));
-                edges.push(edge);
-            }
-            for (const endpoint of [edge.subject_ref, edge.object_ref]) {
-                const before = seenNodes.size;
-                addNode(nodes, seenNodes, endpoint);
-                if (seenNodes.size > before && !nextKeys.has(refKey(endpoint))) {
-                    nextKeys.add(refKey(endpoint));
-                    nextFrontier.push(endpoint);
-                }
-            }
-        }
-        frontier = nextFrontier;
-    }
-    return { nodes, edges };
-}
-function getGraphPaths(adapter, input) {
-    const maxDepth = normalizeDepth(input.max_depth, 3);
-    const limit = normalizeLimit(input.limit, DEFAULT_PATH_LIMIT);
-    const visibility = graphVisibility(input);
-    assertRefsVisible(adapter, [input.from_ref, input.to_ref], visibility, input.as_of_ms);
-    const targetKey = refKey(input.to_ref);
-    const queue = [{ refs: [input.from_ref], edges: [] }];
-    const paths = [];
-    while (queue.length > 0 && paths.length < limit) {
-        const path = queue.shift();
-        if (!path) {
-            break;
-        }
-        const current = path.refs[path.refs.length - 1];
-        if (!current || path.edges.length >= maxDepth) {
-            continue;
-        }
-        const edges = listFilteredEdges(adapter, [current], {
-            visibility,
-            edge_filters: input.edge_filters,
-            as_of_ms: input.as_of_ms,
-        });
-        for (const edge of edges) {
-            for (const next of oppositeRef(edge, current)) {
-                if (path.refs.some((ref) => refKey(ref) === refKey(next))) {
-                    continue;
-                }
-                const nextPath = { refs: [...path.refs, next], edges: [...path.edges, edge] };
-                if (refKey(next) === targetKey) {
-                    paths.push(nextPath);
-                    if (paths.length >= limit) {
-                        break;
-                    }
-                }
-                else {
-                    queue.push(nextPath);
-                }
-            }
-            if (paths.length >= limit) {
-                break;
-            }
-        }
-    }
-    return { paths };
-}
-function getGraphTimeline(adapter, input) {
-    const visibility = graphVisibility(input);
-    assertRefsVisible(adapter, [input.ref], visibility, input.as_of_ms);
-    const limit = normalizeLimit(input.limit, DEFAULT_GRAPH_LIMIT);
-    const window = timelineWindow(input);
-    const edges = listFilteredEdges(adapter, [input.ref], {
-        visibility,
-        edge_filters: input.edge_filters,
-        as_of_ms: input.as_of_ms,
-    }).filter((edge) => isInTimelineWindow(edge.created_at, window));
-    const refs = [];
-    const seenRefs = new Set();
-    addRef(refs, seenRefs, input.ref);
-    for (const edge of edges) {
-        addRef(refs, seenRefs, edge.subject_ref);
-        addRef(refs, seenRefs, edge.object_ref);
-    }
-    const events = [];
-    for (const ref of refs) {
-        const event = loadTimelineRecordEvent(adapter, ref);
-        if (event && isInTimelineWindow(event.at_ms, window)) {
-            events.push(event);
-        }
-    }
-    events.push(...edges.map((edge) => ({ kind: 'edge', at_ms: edge.created_at, edge })));
-    return {
-        ref: input.ref,
-        events: events
-            .sort((left, right) => left.at_ms - right.at_ms ||
-            eventKindRank(left.kind) - eventKindRank(right.kind) ||
-            eventKey(left).localeCompare(eventKey(right)))
-            .slice(0, limit),
-    };
-}
-//# sourceMappingURL=graph-query.js.map

package/dist/agent-graph/index.d.ts

@@ -1,6 +0,0 @@
-export * from './types.js';
-export * from './errors.js';
-export * from './entity-resolve.js';
-export * from './graph-query.js';
-export * from './alias-write.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/agent-situation/builder.d.ts

@@ -1,8 +0,0 @@
-import type { DatabaseAdapter } from '../db-manager.js';
-import { type AgentSituationSourceReadInput, type VisibleAgentSituationSources } from './source-readers.js';
-import type { AgentSituationInput, AgentSituationPacketRecord } from './types.js';
-type SituationBuilderAdapter = Pick<DatabaseAdapter, 'prepare'>;
-export declare function listVisibleAgentSituationSources(adapter: SituationBuilderAdapter, input: AgentSituationSourceReadInput): VisibleAgentSituationSources;
-export declare function buildAgentSituationPacketRecord(adapter: SituationBuilderAdapter, input: AgentSituationInput): AgentSituationPacketRecord;
-export {};
-//# sourceMappingURL=builder.d.ts.map

package/dist/agent-situation/builder.js

@@ -1,239 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.listVisibleAgentSituationSources = listVisibleAgentSituationSources;
-exports.buildAgentSituationPacketRecord = buildAgentSituationPacketRecord;
-const node_crypto_1 = require("node:crypto");
-const canonicalize_js_1 = require("../canonicalize.js");
-const cache_key_js_1 = require("./cache-key.js");
-const ranking_policy_js_1 = require("./ranking-policy.js");
-const source_readers_js_1 = require("./source-readers.js");
-function iso(ms) {
-    return new Date(ms).toISOString();
-}
-function ttlForRange(rangeStartMs, rangeEndMs) {
-    const rangeMs = Math.max(0, rangeEndMs - rangeStartMs);
-    const dayMs = 24 * 60 * 60 * 1000;
-    if (rangeMs <= 7 * dayMs) {
-        return 120;
-    }
-    if (rangeMs <= 30 * dayMs) {
-        return 300;
-    }
-    return 900;
-}
-function topStrings(values, limit = 3) {
-    return values
-        .map((value) => value.trim())
-        .filter(Boolean)
-        .slice(0, limit);
-}
-function refKey(ref) {
-    return `${ref.kind}:${ref.id}`;
-}
-function buildBriefing(sources) {
-    const memories = sources.memories;
-    const openQuestions = memories.filter((memory) => memory.is_open_question);
-    const lowConfidence = [...memories, ...sources.cases, ...sources.edges].filter((candidate) => typeof candidate.confidence === 'number' && candidate.confidence < 0.6);
-    return {
-        decisions: topStrings(memories.map((memory) => memory.summary || memory.title)),
-        facts: topStrings(sources.raw.map((raw) => raw.summary)),
-        open_questions: topStrings(openQuestions.map((memory) => memory.summary || memory.title)),
-        risks: topStrings([
-            ...lowConfidence.map((candidate) => candidate.summary || candidate.title),
-            ...sources.cases
-                .filter((item) => item.status === 'blocked')
-                .map((item) => `${item.title}: ${item.status}`),
-        ]),
-    };
-}
-function buildCoverage(sources, input) {
-    const coverage = [];
-    for (const connector of input.effective_filters.connectors) {
-        for (const scope of input.effective_filters.scopes) {
-            const raw = sources.raw.filter((item) => item.connector === connector &&
-                item.scope?.kind === scope.kind &&
-                item.scope.id === scope.id);
-            const memories = sources.memories.filter((item) => item.scope?.kind === scope.kind && item.scope.id === scope.id);
-            const cases = sources.cases.filter((item) => item.scope?.kind === scope.kind && item.scope.id === scope.id);
-            const rowRefs = new Set([...raw, ...memories, ...cases].map((item) => refKey(item.ref)));
-            const edges = sources.edges.filter((item) => rowRefs.has(refKey(item.subject_ref)) && rowRefs.has(refKey(item.object_ref)));
-            const lastSeenMs = Math.max(0, ...raw.map((item) => item.timestamp_ms), ...memories.map((item) => item.timestamp_ms), ...cases.map((item) => item.timestamp_ms), ...edges.map((item) => item.timestamp_ms));
-            coverage.push({
-                connector,
-                channel_id: raw[0]?.channel_id ?? null,
-                memory_scope: scope,
-                raw_count: raw.length,
-                memory_count: memories.length,
-                case_count: cases.length,
-                edge_count: edges.length,
-                last_seen: lastSeenMs > 0 ? iso(lastSeenMs) : null,
-                stale: lastSeenMs > 0
-                    ? (input.now_ms ?? Date.now()) - lastSeenMs > 30 * 24 * 60 * 60 * 1000
-                    : true,
-            });
-        }
-    }
-    return coverage;
-}
-function buildRankedItems(sources, limit) {
-    const policy = (0, ranking_policy_js_1.getAgentSituationRankingPolicy)();
-    const candidates = [...sources.raw, ...sources.memories, ...sources.cases, ...sources.edges];
-    return candidates
-        .map((candidate) => {
-        const score = (0, ranking_policy_js_1.scoreAgentSituationCandidate)(candidate, policy);
-        return {
-            ref: candidate.ref,
-            kind: candidate.kind,
-            score: score.score,
-            reasons: score.reasons,
-            caveats: score.caveats,
-        };
-    })
-        .sort((left, right) => right.score - left.score || left.ref.id.localeCompare(right.ref.id))
-        .slice(0, limit);
-}
-function buildRecommendations(sources, rankedItems) {
-    const recommendations = [];
-    const expectedRefs = rankedItems.map((item) => item.ref);
-    if (sources.memories.some((memory) => memory.is_open_question) || sources.raw.length > 0) {
-        recommendations.push({
-            tool: 'raw.searchAll',
-            args: {
-                query: sources.memories.find((memory) => memory.is_open_question)?.title ?? 'recent work',
-            },
-            reason: 'visible_open_question_needs_evidence',
-            expected_refs: expectedRefs.filter((ref) => ref.kind === 'raw' || ref.kind === 'memory'),
-        });
-    }
-    const topRaw = sources.raw[0];
-    if (topRaw) {
-        recommendations.push({
-            tool: 'raw.window',
-            args: { raw_id: topRaw.ref.id },
-            reason: 'inspect_visible_raw_context',
-            expected_refs: [topRaw.ref],
-        });
-    }
-    return recommendations;
-}
-function sourceRefs(sources) {
-    return [
-        ...sources.raw.map((item) => item.ref),
-        ...sources.memories.map((item) => item.ref),
-        ...sources.cases.map((item) => item.ref),
-        ...sources.edges.map((item) => item.ref),
-    ];
-}
-function primaryScope(input) {
-    const scope = input.scope[0] ?? input.effective_filters.scopes[0];
-    if (!scope) {
-        throw new Error('agent.situation requires at least one effective memory scope');
-    }
-    return scope;
-}
-function primaryProjectId(input) {
-    const project = input.effective_filters.project_refs[0];
-    if (!project) {
-        throw new Error('agent.situation requires at least one effective project ref');
-    }
-    return project.id;
-}
-function json(value) {
-    return (0, canonicalize_js_1.canonicalizeJSON)(value);
-}
-function listVisibleAgentSituationSources(adapter, input) {
-    return (0, source_readers_js_1.listVisibleAgentSituationSources)(adapter, input);
-}
-function buildAgentSituationPacketRecord(adapter, input) {
-    const rankingPolicyVersion = input.ranking_policy_version ?? ranking_policy_js_1.AGENT_SITUATION_V0_POLICY_VERSION;
-    const nowMs = Math.floor(input.now_ms ?? Date.now());
-    const limit = Math.floor(input.limit);
-    const effectiveFilters = (0, cache_key_js_1.normalizeAgentSituationEffectiveFilters)(input.effective_filters);
-    const normalizedInput = { ...input, effective_filters: effectiveFilters };
-    const sources = (0, source_readers_js_1.listVisibleAgentSituationSources)(adapter, {
-        effective_filters: effectiveFilters,
-        range_start_ms: input.range_start_ms,
-        range_end_ms: input.range_end_ms,
-        limit,
-    });
-    const key = (0, cache_key_js_1.buildAgentSituationCacheKey)({
-        ...effectiveFilters,
-        range_start_ms: input.range_start_ms,
-        range_end_ms: input.range_end_ms,
-        focus: input.focus,
-        limit,
-        ranking_policy_version: rankingPolicyVersion,
-    });
-    const ttlSeconds = ttlForRange(input.range_start_ms, input.range_end_ms);
-    const expiresAt = nowMs + ttlSeconds * 1000;
-    const scope = primaryScope(input);
-    const rankedItems = buildRankedItems(sources, limit);
-    const briefing = buildBriefing(sources);
-    const coverage = buildCoverage(sources, normalizedInput);
-    const visibleSourceRefs = sourceRefs(sources);
-    const pendingHumanQuestions = sources.memories
-        .filter((memory) => memory.is_open_question)
-        .slice(0, 3)
-        .map((memory) => ({
-        memory_id: memory.ref.id,
-        title: memory.title,
-        summary: memory.summary,
-    }));
-    const caveats = visibleSourceRefs.length === 0 ? ['no_visible_sources'] : [];
-    const recommendedNextTools = buildRecommendations(sources, rankedItems);
-    const topMemoryRefs = sources.memories.map((memory) => memory.ref.id).slice(0, limit);
-    const freshness = {
-        generated_at_ms: nowMs,
-        visible_source_count: visibleSourceRefs.length,
-    };
-    return {
-        packet_id: `situ_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`,
-        cache_key: key.cacheKey,
-        scope_json: json(input.scope),
-        scope: input.scope,
-        scope_hash: key.scopeHash,
-        range_start_ms: Math.floor(input.range_start_ms),
-        range_end_ms: Math.floor(input.range_end_ms),
-        focus_json: json(input.focus),
-        focus: input.focus,
-        envelope_hash: input.envelope_hash,
-        envelope_effective_filters_json: json(effectiveFilters),
-        envelope_effective_filters: effectiveFilters,
-        envelope_effective_filters_hash: key.filtersHash,
-        ranking_policy_version: rankingPolicyVersion,
-        generated_at: nowMs,
-        expires_at: expiresAt,
-        ttl_seconds: ttlSeconds,
-        freshness_json: json(freshness),
-        freshness,
-        source_coverage_json: json(coverage),
-        source_coverage: coverage,
-        briefing_json: json(briefing),
-        briefing,
-        ranked_items_json: json(rankedItems),
-        ranked_items: rankedItems,
-        top_memory_refs_json: json(topMemoryRefs),
-        top_memory_refs: topMemoryRefs,
-        pending_human_questions_json: json(pendingHumanQuestions),
-        pending_human_questions: pendingHumanQuestions,
-        entity_clusters_json: '[]',
-        entity_clusters: [],
-        recommended_next_tools_json: json(recommendedNextTools),
-        recommended_next_tools: recommendedNextTools,
-        generated_from_slice_ids_json: '[]',
-        generated_from_slice_ids: [],
-        caveats_json: json(caveats),
-        caveats,
-        agent_id: input.agent_id,
-        model_run_id: input.model_run_id,
-        input_snapshot_ref: `situation:${key.cacheKey}`,
-        source_refs_json: json(visibleSourceRefs),
-        source_refs: visibleSourceRefs,
-        tenant_id: effectiveFilters.tenant_id,
-        project_id: primaryProjectId(normalizedInput),
-        memory_scope_kind: scope.kind,
-        memory_scope_id: scope.id,
-        created_at: nowMs,
-    };
-}
-//# sourceMappingURL=builder.js.map

package/dist/agent-situation/cache-key.d.ts

@@ -1,4 +0,0 @@
-import type { AgentSituationCacheKeyInput, AgentSituationCacheKeyResult, AgentSituationEffectiveFilters } from './types.js';
-export declare function normalizeAgentSituationEffectiveFilters(input: AgentSituationEffectiveFilters): AgentSituationEffectiveFilters;
-export declare function buildAgentSituationCacheKey(input: AgentSituationCacheKeyInput): AgentSituationCacheKeyResult;
-//# sourceMappingURL=cache-key.d.ts.map

package/dist/agent-situation/cache-key.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeAgentSituationEffectiveFilters = normalizeAgentSituationEffectiveFilters;
-exports.buildAgentSituationCacheKey = buildAgentSituationCacheKey;
-const node_crypto_1 = require("node:crypto");
-const canonicalize_js_1 = require("../canonicalize.js");
-function sha256Hex(value) {
-    return (0, node_crypto_1.createHash)('sha256').update((0, canonicalize_js_1.canonicalizeJSON)(value), 'utf8').digest('hex');
-}
-function uniqueSorted(values) {
-    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort();
-}
-function normalizeScopes(scopes) {
-    const byKey = new Map();
-    for (const scope of scopes) {
-        const normalized = { kind: scope.kind, id: scope.id.trim() };
-        if (normalized.id.length > 0) {
-            byKey.set(`${normalized.kind}:${normalized.id}`, normalized);
-        }
-    }
-    return [...byKey.values()].sort((left, right) => `${left.kind}:${left.id}`.localeCompare(`${right.kind}:${right.id}`));
-}
-function normalizeProjectRefs(projectRefs) {
-    const byId = new Map();
-    for (const project of projectRefs) {
-        const normalized = { kind: 'project', id: project.id.trim() };
-        if (normalized.id.length > 0) {
-            byId.set(normalized.id, normalized);
-        }
-    }
-    return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
-}
-function normalizeFocus(focus) {
-    return [...new Set(focus)].sort();
-}
-function normalizeAgentSituationEffectiveFilters(input) {
-    return {
-        scopes: normalizeScopes(input.scopes),
-        connectors: uniqueSorted(input.connectors),
-        project_refs: normalizeProjectRefs(input.project_refs),
-        tenant_id: input.tenant_id.trim() || 'default',
-        as_of: input.as_of ?? null,
-    };
-}
-function buildAgentSituationCacheKey(input) {
-    const effective = normalizeAgentSituationEffectiveFilters(input);
-    const canonicalInput = {
-        ...effective,
-        range_start_ms: Math.floor(input.range_start_ms),
-        range_end_ms: Math.floor(input.range_end_ms),
-        focus: normalizeFocus(input.focus),
-        limit: Math.floor(input.limit),
-        ranking_policy_version: input.ranking_policy_version,
-    };
-    const canonicalJson = (0, canonicalize_js_1.canonicalizeJSON)(canonicalInput);
-    return {
-        cacheKey: (0, node_crypto_1.createHash)('sha256').update(canonicalJson, 'utf8').digest('hex'),
-        canonicalInput,
-        canonicalJson,
-        filtersHash: sha256Hex(effective),
-        scopeHash: sha256Hex(effective.scopes),
-    };
-}
-//# sourceMappingURL=cache-key.js.map

package/dist/agent-situation/index.d.ts

@@ -1,7 +0,0 @@
-export * from './types.js';
-export * from './cache-key.js';
-export * from './ranking-policy.js';
-export { listVisibleRawCandidates, listVisibleMemoryCandidates, listVisibleCaseCandidates, listVisibleEdgeCandidates, type AgentSituationSourceReadInput, type VisibleAgentSituationSources, type VisibleRawCandidate, type VisibleMemoryCandidate, type VisibleCaseCandidate, type VisibleEdgeCandidate, } from './source-readers.js';
-export * from './builder.js';
-export * from './packet-store.js';
-//# sourceMappingURL=index.d.ts.map