squish-memory 1.2.0 → 1.2.1

package/dist/core/tracing/visualizer.d.ts

@@ -1,32 +0,0 @@
-/** Trace Visualizer - Creates ASCII visualizations of search traces
- *
- * Provides tree-format output showing search pipeline stages and timing
- */
-import { SearchTrace } from './collector.js';
-/**
- * Create visual ASCII visualization of a trace
- */
-export declare function visualizeTrace(trace: SearchTrace): string;
-/**
- * Create compact single-line trace summary
- */
-export declare function summarizeTrace(trace: SearchTrace): string;
-/**
- * Compare multiple traces
- */
-export declare function compareTraces(traces: SearchTrace[]): string;
-/**
- * Get stage breakdown table
- */
-export declare function getStageBreakdown(trace: SearchTrace): string;
-/**
- * Export all visualizer functions
- */
-declare const _default: {
-    visualizeTrace: typeof visualizeTrace;
-    summarizeTrace: typeof summarizeTrace;
-    compareTraces: typeof compareTraces;
-    getStageBreakdown: typeof getStageBreakdown;
-};
-export default _default;
-//# sourceMappingURL=visualizer.d.ts.map

package/dist/core/tracing/visualizer.js

@@ -1,165 +0,0 @@
-/** Trace Visualizer - Creates ASCII visualizations of search traces
- *
- * Provides tree-format output showing search pipeline stages and timing
- */
-/**
- * Create visual ASCII visualization of a trace
- */
-export function visualizeTrace(trace) {
-    const lines = [];
-    // Header
-    lines.push('='.repeat(60));
-    lines.push(`Search Trace: ${trace.id}`);
-    lines.push(`Session: ${trace.sessionId || 'N/A'}`);
-    lines.push(`Query: "${trace.query}"`);
-    lines.push('='.repeat(60));
-    lines.push('');
-    // Total duration
-    lines.push(`Total Duration: ${trace.totalDurationMs}ms (${(trace.totalDurationMs / 1000).toFixed(2)}s)`);
-    lines.push('');
-    // Stage timeline visualization
-    lines.push('─'.repeat(60));
-    lines.push('Pipeline Stages:');
-    lines.push('─'.repeat(60));
-    lines.push('');
-    const stageNames = [];
-    const stageTimings = [];
-    if (trace.queryRewrite) {
-        stageNames.push('Query Rewrite');
-        stageTimings.push(trace.queryRewrite.timeMs || 0);
-    }
-    if (trace.candidateRetrieval) {
-        stageNames.push('Candidate Retrieval');
-        stageTimings.push(trace.candidateRetrieval.timeMs || 0);
-    }
-    if (trace.entityFiltering) {
-        stageNames.push('Entity Filtering');
-        stageTimings.push(trace.entityFiltering.timeMs || 0);
-    }
-    if (trace.hybridScoring) {
-        stageNames.push('Hybrid Scoring');
-        stageTimings.push(trace.hybridScoring.timeMs || 0);
-    }
-    if (trace.reranking) {
-        stageNames.push('Reranking');
-        stageTimings.push(trace.reranking.timeMs || 0);
-    }
-    if (stageNames.length > 0) {
-        let cumulativeTime = 0;
-        const maxStageNameLength = Math.max(...stageNames.map(n => n.length));
-        stageNames.forEach((name, i) => {
-            const duration = stageTimings[i] || 0;
-            cumulativeTime += duration;
-            const progressPercent = ((cumulativeTime / trace.totalDurationMs) * 100).toFixed(1);
-            const barLength = Math.max(0, Math.min(40, Math.round((duration / trace.totalDurationMs) * 40)));
-            // Stage name with timing
-            const paddedName = name.padEnd(maxStageNameLength + 2);
-            lines.push(`${paddedName} │ ${duration.toString().padStart(4)}ms │ ${progressPercent.padStart(5)}%`);
-            // Visualization bar
-            const bar = '█'.repeat(barLength) + '░'.repeat(40 - barLength);
-            lines.push(`           └─ ${bar}`);
-            lines.push('');
-        });
-    }
-    else {
-        lines.push('  No stage data available');
-        lines.push('');
-    }
-    // Top results
-    if (trace.topResults && trace.topResults.length > 0) {
-        lines.push('─'.repeat(60));
-        lines.push(`Top Results (${trace.topResults.length}):`);
-        lines.push('─'.repeat(60));
-        lines.push('');
-        trace.topResults.slice(0, 5).forEach((result, i) => {
-            const type = result.type || 'memory';
-            const content = result.content?.substring(0, 60) || '';
-            const score = result.hybridScore?.toFixed(2) || 'N/A';
-            lines.push(`${(i + 1).toString().padStart(2)}. [${type.padEnd(8)}] (score: ${score})`);
-            if (content.length > 0) {
-                lines.push(`    ${content}`);
-            }
-            lines.push('');
-        });
-    }
-    else if (trace.resultCount !== undefined) {
-        lines.push('─'.repeat(60));
-        lines.push(`Results: ${trace.resultCount} returned`);
-        lines.push('─'.repeat(60));
-        lines.push('');
-    }
-    // Footer
-    lines.push('='.repeat(60));
-    lines.push('');
-    return lines.join('\n');
-}
-/**
- * Create compact single-line trace summary
- */
-export function summarizeTrace(trace) {
-    const parts = [];
-    parts.push(`[${trace.id.substring(0, 8)}]`);
-    parts.push(`"${trace.query.substring(0, 30)}${trace.query.length > 30 ? '...' : ''}"`);
-    parts.push(`${trace.totalDurationMs}ms`);
-    parts.push(trace.resultCount !== undefined ? `${trace.resultCount} results` : 'unknown');
-    return parts.join(' | ');
-}
-/**
- * Compare multiple traces
- */
-export function compareTraces(traces) {
-    const lines = [];
-    lines.push('─'.repeat(80));
-    lines.push('Trace Comparison');
-    lines.push('─'.repeat(80));
-    lines.push('');
-    lines.push('ID'.padEnd(10) + ' | ' + 'Query'.padEnd(30) + ' | ' + 'Duration'.padEnd(10) + ' | ' + 'Results');
-    lines.push('─'.repeat(80));
-    traces.forEach(trace => {
-        const id = trace.id.substring(0, 8);
-        const query = trace.query.substring(0, 30);
-        const duration = `${trace.totalDurationMs}ms`;
-        const results = trace.resultCount !== undefined ? trace.resultCount.toString() : '?';
-        lines.push(`${id.padEnd(10)} | ${query.padEnd(30)} | ${duration.padEnd(10)} | ${results.padEnd(8)}`);
-    });
-    return lines.join('\n');
-}
-/**
- * Get stage breakdown table
- */
-export function getStageBreakdown(trace) {
-    const lines = [];
-    lines.push('Stage Timing Breakdown:');
-    lines.push('');
-    const stages = [
-        { name: 'Query Rewrite', data: trace.queryRewrite, timeMs: trace.queryRewrite?.timeMs || 0 },
-        { name: 'Candidate Retrieval', data: trace.candidateRetrieval, timeMs: trace.candidateRetrieval?.timeMs || 0 },
-        { name: 'Entity Filtering', data: trace.entityFiltering, timeMs: trace.entityFiltering?.timeMs || 0 },
-        { name: 'Hybrid Scoring', data: trace.hybridScoring, timeMs: trace.hybridScoring?.timeMs || 0 },
-        { name: 'Reranking', data: trace.reranking, timeMs: trace.reranking?.timeMs || 0 },
-    ];
-    const validStages = stages.filter(s => s.data && s.timeMs !== undefined);
-    if (validStages.length > 0) {
-        const maxNameLength = Math.max(...validStages.map(s => s.name.length));
-        validStages.forEach(stage => {
-            const percentage = ((stage.timeMs / trace.totalDurationMs) * 100).toFixed(1);
-            lines.push(`  ${stage.name.padEnd(maxNameLength)} │ ${stage.timeMs.toString().padStart(4)}ms │ ${percentage.padStart(5)}%`);
-        });
-        lines.push('');
-        lines.push('  ' + '─'.repeat(maxNameLength + 4 + 5 + 6));
-    }
-    else {
-        lines.push('  No stage timing data available');
-    }
-    return lines.join('\n');
-}
-/**
- * Export all visualizer functions
- */
-export default {
-    visualizeTrace,
-    summarizeTrace,
-    compareTraces,
-    getStageBreakdown,
-};
-//# sourceMappingURL=visualizer.js.map

package/dist/core/utils/cleanup-operations.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shared Cleanup Operations Utilities
- * Common patterns for age-based cleanup operations
- */
-/**
- * Cleanup old session summaries
- */
-export declare function cleanupOldSessionSummaries(olderThanDays?: number): Promise<number>;
-/**
- * Cleanup old memory snapshots
- */
-export declare function cleanupOldMemorySnapshots(olderThanDays?: number): Promise<number>;
-//# sourceMappingURL=cleanup-operations.d.ts.map

package/dist/core/utils/cleanup-operations.js

@@ -1,44 +0,0 @@
-/**
- * Shared Cleanup Operations Utilities
- * Common patterns for age-based cleanup operations
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Cleanup old session summaries
- */
-export async function cleanupOldSessionSummaries(olderThanDays = 30) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const threshold = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
-        const result = await db
-            .delete(schema.sessionSummaries)
-            .where(schema.sessionSummaries.createdAt < threshold);
-        return result?.rowCount || 0;
-    }
-    catch (error) {
-        logger.error('Error pruning old summaries', error);
-        return 0;
-    }
-}
-/**
- * Cleanup old memory snapshots
- */
-export async function cleanupOldMemorySnapshots(olderThanDays = 90) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const threshold = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
-        const result = await db
-            .delete(schema.memorySnapshots)
-            .where(schema.memorySnapshots.createdAt < threshold);
-        return result?.rowCount || 0;
-    }
-    catch (error) {
-        logger.error('Error deleting old snapshots', error);
-        return 0;
-    }
-}
-//# sourceMappingURL=cleanup-operations.js.map

package/dist/core/utils/content-extraction.d.ts

@@ -1,19 +0,0 @@
-/**
- * Shared Content Extraction Utilities
- * Common patterns for extracting information from messages
- */
-/**
- * Extract key information from conversation messages
- */
-export declare function extractMessageContent(messages: any[]): {
-    userMessages: any[];
-    assistantMessages: any[];
-    toolCalls: Set<string>;
-    topics: Set<string>;
-    timestamp: string;
-};
-/**
- * Generate basic extractive summary from extracted content
- */
-export declare function generateExtractiveSummary(extracted: ReturnType<typeof extractMessageContent>): string;
-//# sourceMappingURL=content-extraction.d.ts.map

package/dist/core/utils/content-extraction.js

@@ -1,75 +0,0 @@
-/**
- * Shared Content Extraction Utilities
- * Common patterns for extracting information from messages
- */
-/**
- * Extract key information from conversation messages
- */
-export function extractMessageContent(messages) {
-    // Extract key information from messages
-    const userMessages = messages.filter((m) => m.role === 'user');
-    const assistantMessages = messages.filter((m) => m.role === 'assistant');
-    // Extract tool calls
-    const toolCalls = new Set();
-    for (const msg of messages) {
-        if (msg.toolCalls && Array.isArray(msg.toolCalls)) {
-            for (const tc of msg.toolCalls) {
-                toolCalls.add(tc.name);
-            }
-        }
-    }
-    // Extract topics from first and last user messages
-    const topics = new Set();
-    if (userMessages.length > 0) {
-        const firstUser = userMessages[0].content || '';
-        const lastUser = userMessages[userMessages.length - 1].content || '';
-        // Simple topic extraction (first 10 words)
-        const extractTopics = (text) => {
-            const words = text.split(/\s+/).slice(0, 10);
-            return words.join(' ');
-        };
-        if (firstUser)
-            topics.add(extractTopics(firstUser));
-        if (lastUser && lastUser !== firstUser)
-            topics.add(extractTopics(lastUser));
-    }
-    const timestamp = messages.length > 0 ? messages[messages.length - 1].createdAt : 'unknown';
-    return {
-        userMessages,
-        assistantMessages,
-        toolCalls,
-        topics,
-        timestamp,
-    };
-}
-/**
- * Generate basic extractive summary from extracted content
- */
-export function generateExtractiveSummary(extracted) {
-    const hasContent = extracted.userMessages.length > 0 ||
-        extracted.assistantMessages.length > 0 ||
-        extracted.toolCalls.size > 0 ||
-        extracted.topics.size > 0 ||
-        extracted.timestamp !== 'unknown';
-    if (!hasContent) {
-        return '';
-    }
-    const parts = [];
-    if (extracted.userMessages.length > 0) {
-        parts.push(`User prompts: ${extracted.userMessages.length}`);
-    }
-    if (extracted.assistantMessages.length > 0) {
-        parts.push(`Assistant responses: ${extracted.assistantMessages.length}`);
-    }
-    if (extracted.toolCalls.size > 0) {
-        parts.push(`Tools used: ${Array.from(extracted.toolCalls).join(', ')}`);
-    }
-    if (extracted.topics.size > 0) {
-        parts.push(`Topics: ${Array.from(extracted.topics).join('; ')}`);
-    }
-    if (extracted.timestamp !== 'unknown') {
-        parts.push(`Last activity: ${extracted.timestamp}`);
-    }
-    return parts.join('. ');
-}
-//# sourceMappingURL=content-extraction.js.map

package/dist/core/utils/filter-builder.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shared Requirements Filter Builder
- * Common patterns for building database filters from criteria objects
- */
-/**
- * Build database filter array from MemoryCriteria
- */
-export declare function buildMemoryFilters(criteria: any, schema: any): any[];
-/**
- * Build database filter array from partial criteria (for assertions)
- */
-export declare function buildMemoryFiltersPartial(criteria: any, schema: any): any[];
-//# sourceMappingURL=filter-builder.d.ts.map

package/dist/core/utils/filter-builder.js

@@ -1,44 +0,0 @@
-/**
- * Shared Requirements Filter Builder
- * Common patterns for building database filters from criteria objects
- */
-import { eq, inArray, gte } from 'drizzle-orm';
-/**
- * Build database filter array from MemoryCriteria
- */
-export function buildMemoryFilters(criteria, schema) {
-    const filters = [];
-    if (criteria.type) {
-        filters.push(eq(schema.memories.type, criteria.type));
-    }
-    if (criteria.types && criteria.types.length > 0) {
-        filters.push(inArray(schema.memories.type, criteria.types));
-    }
-    if (criteria.sector) {
-        filters.push(eq(schema.memories.sector, criteria.sector));
-    }
-    if (criteria.minConfidence !== undefined) {
-        filters.push(gte(schema.memories.confidence, criteria.minConfidence));
-    }
-    if (criteria.minRelevance !== undefined) {
-        filters.push(gte(schema.memories.relevanceScore, criteria.minRelevance));
-    }
-    if (criteria.projectId) {
-        filters.push(eq(schema.memories.projectId, criteria.projectId));
-    }
-    if (criteria.agentId) {
-        filters.push(eq(schema.memories.agentId, criteria.agentId));
-    }
-    return filters;
-}
-/**
- * Build database filter array from partial criteria (for assertions)
- */
-export function buildMemoryFiltersPartial(criteria, schema) {
-    const filters = [];
-    if (criteria.type) {
-        filters.push(eq(schema.memories.type, criteria.type));
-    }
-    return filters;
-}
-//# sourceMappingURL=filter-builder.js.map

package/dist/core/utils/history-traversal.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shared History and Version Tracking Utilities
- * Common patterns for traversing version chains and history
- */
-/**
- * Traverse superseded fact chain (specific to memories table)
- * Follows the supersededBy chain to build complete version history
- */
-export declare function traverseSupersededChain(startFactId: string, options?: {
-    maxDepth?: number;
-    includeStart?: boolean;
-}): Promise<any[]>;
-//# sourceMappingURL=history-traversal.d.ts.map

package/dist/core/utils/history-traversal.js

@@ -1,50 +0,0 @@
-/**
- * Shared History and Version Tracking Utilities
- * Common patterns for traversing version chains and history
- */
-import { eq } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Traverse superseded fact chain (specific to memories table)
- * Follows the supersededBy chain to build complete version history
- */
-export async function traverseSupersededChain(startFactId, options = {}) {
-    const { maxDepth = 50, includeStart = true } = options;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get the starting fact
-        const initial = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.id, startFactId))
-            .limit(1);
-        if (initial.length === 0) {
-            return [];
-        }
-        const history = includeStart ? [initial[0]] : [];
-        let currentId = initial[0].supersededBy;
-        let depth = 0;
-        // Follow the superseded chain
-        while (currentId && depth < maxDepth) {
-            const next = await db
-                .select()
-                .from(schema.memories)
-                .where(eq(schema.memories.id, currentId))
-                .limit(1);
-            if (next.length === 0)
-                break;
-            history.push(next[0]);
-            currentId = next[0].supersededBy;
-            depth++;
-        }
-        return history;
-    }
-    catch (error) {
-        logger.error('Error traversing superseded chain', error);
-        return [];
-    }
-}
-//# sourceMappingURL=history-traversal.js.map

package/dist/core/utils/memory-operations.d.ts

@@ -1,17 +0,0 @@
-/**
- * Shared Memory Operations Utilities
- * Common patterns for memory governance operations
- */
-/**
- * Generic memory operation with governance checks and error handling
- */
-export declare function performMemoryOperation(memoryId: string, operation: {
-    name: string;
-    updates: Record<string, any>;
-    requiresGovernance?: boolean;
-}): Promise<void>;
-/**
- * Redis publish operation with error handling
- */
-export declare function performRedisPublish(getRedisClient: () => Promise<any>, channel: string, message: unknown): Promise<void>;
-//# sourceMappingURL=memory-operations.d.ts.map

package/dist/core/utils/memory-operations.js

@@ -1,43 +0,0 @@
-/**
- * Shared Memory Operations Utilities
- * Common patterns for memory governance operations
- */
-import { eq } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../storage/database.js';
-import { config } from '../../config.js';
-import { logger } from '../logger.js';
-/**
- * Generic memory operation with governance checks and error handling
- */
-export async function performMemoryOperation(memoryId, operation) {
-    if (operation.requiresGovernance !== false && !config.governanceEnabled) {
-        return;
-    }
-    try {
-        const db = await getDb();
-        const client = createDatabaseClient(db);
-        const schema = await getSchema();
-        await client
-            .update(schema.memories)
-            .set(operation.updates)
-            .where(eq(schema.memories.id, memoryId));
-    }
-    catch (error) {
-        logger.error(`Error ${operation.name.toLowerCase()}`, error);
-    }
-}
-/**
- * Redis publish operation with error handling
- */
-export async function performRedisPublish(getRedisClient, channel, message) {
-    try {
-        const redis = await getRedisClient();
-        await redis.publish(channel, JSON.stringify(message));
-    }
-    catch (error) {
-        logger.error('Error publishing to Redis', error);
-    }
-}
-//# sourceMappingURL=memory-operations.js.map

package/dist/core/utils/query-operations.d.ts

@@ -1,18 +0,0 @@
-/**
- * Shared Requirements Query Operations
- * Common patterns for database queries with error handling
- */
-export declare class MemoryRequirementError extends Error {
-    readonly missingCriteria: any;
-    readonly context?: any | undefined;
-    constructor(message: string, missingCriteria: any, context?: any | undefined);
-}
-/**
- * Execute a memory requirement query with standard error handling
- */
-export declare function executeMemoryQuery(criteria: any, filters: any[], limit?: number, operation?: string): Promise<any[]>;
-/**
- * Execute a memory assertion query (expecting specific results)
- */
-export declare function executeMemoryAssertion(criteria: any, filters: any[], expectedCount: number, operation: string, errorMessage: string): Promise<any[]>;
-//# sourceMappingURL=query-operations.d.ts.map

package/dist/core/utils/query-operations.js

@@ -1,65 +0,0 @@
-/**
- * Shared Requirements Query Operations
- * Common patterns for database queries with error handling
- */
-import { and } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-export class MemoryRequirementError extends Error {
-    missingCriteria;
-    context;
-    constructor(message, missingCriteria, context) {
-        super(message);
-        this.missingCriteria = missingCriteria;
-        this.context = context;
-        this.name = 'MemoryRequirementError';
-        Object.setPrototypeOf(this, MemoryRequirementError.prototype);
-    }
-}
-/**
- * Execute a memory requirement query with standard error handling
- */
-export async function executeMemoryQuery(criteria, filters, limit = 1, operation = 'memory requirement') {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const query = filters.length > 0 ? and(...filters) : undefined;
-        const memories = await db
-            .select()
-            .from(schema.memories)
-            .where(query)
-            .limit(limit);
-        return memories;
-    }
-    catch (error) {
-        if (error instanceof MemoryRequirementError) {
-            throw error;
-        }
-        const msg = error instanceof Error ? error.message : String(error);
-        throw new MemoryRequirementError(`Error checking ${operation}: ${msg}`, criteria);
-    }
-}
-/**
- * Execute a memory assertion query (expecting specific results)
- */
-export async function executeMemoryAssertion(criteria, filters, expectedCount, operation, errorMessage) {
-    try {
-        const memories = await executeMemoryQuery(criteria, filters, 100, operation);
-        if (expectedCount === 0 && memories.length > 0) {
-            throw new MemoryRequirementError(errorMessage, criteria, { found: memories[0].id });
-        }
-        if (expectedCount > 0 && memories.length < expectedCount) {
-            const msg = `Required ${expectedCount} memories but found ${memories.length}`;
-            throw new MemoryRequirementError(msg, criteria, { found: memories.length, required: expectedCount });
-        }
-        return memories;
-    }
-    catch (error) {
-        if (error instanceof MemoryRequirementError) {
-            throw error;
-        }
-        const msg = error instanceof Error ? error.message : String(error);
-        throw new MemoryRequirementError(`Error ${operation}: ${msg}`, criteria);
-    }
-}
-//# sourceMappingURL=query-operations.js.map

package/dist/core/utils/summarization-helpers.d.ts

@@ -1,17 +0,0 @@
-/**
- * Shared Summarization Strategy Utilities
- * Common patterns for different summarization approaches
- */
-/**
- * Chunk messages for incremental summarization
- */
-export declare function chunkMessages(messages: any[], chunkSize: number): any[][];
-/**
- * Get rolling window of messages
- */
-export declare function getRollingWindow(messages: any[], windowSize: number): any[];
-/**
- * Calculate tokens saved by summarization
- */
-export declare function calculateTokensSaved(messages: any[], summary: string): number;
-//# sourceMappingURL=summarization-helpers.d.ts.map

package/dist/core/utils/summarization-helpers.js

@@ -1,33 +0,0 @@
-/**
- * Shared Summarization Strategy Utilities
- * Common patterns for different summarization approaches
- */
-import { estimateTokens } from '../context/context-window.js';
-/**
- * Chunk messages for incremental summarization
- */
-export function chunkMessages(messages, chunkSize) {
-    const chunks = [];
-    for (let i = 0; i < messages.length; i += chunkSize) {
-        chunks.push(messages.slice(i, i + chunkSize));
-    }
-    return chunks;
-}
-/**
- * Get rolling window of messages
- */
-export function getRollingWindow(messages, windowSize) {
-    if (windowSize <= 0) {
-        return [];
-    }
-    return messages.slice(-windowSize);
-}
-/**
- * Calculate tokens saved by summarization
- */
-export function calculateTokensSaved(messages, summary) {
-    const originalTokens = messages.reduce((sum, m) => sum + estimateTokens(m.content || ''), 0);
-    const summaryTokens = estimateTokens(summary);
-    return Math.max(0, originalTokens - summaryTokens);
-}
-//# sourceMappingURL=summarization-helpers.js.map