squish-memory 1.2.0 → 1.2.1

package/dist/core/memory/migrate.js

@@ -1,134 +0,0 @@
-/**
- * Memory Migration Module
- * Migrate memories between .squish directories/databases
- */
-import { randomUUID } from 'crypto';
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { getDbClient } from '../lib/db-client.js';
-/**
- * Migrate memories from one .squish directory to another
- */
-export async function migrateMemories(sourceDir, targetDir, options = {}) {
-    const { dryRun = false, deleteSource = false } = options;
-    const sourceDbPath = join(sourceDir, 'squish.db');
-    const targetDbPath = join(targetDir, 'squish.db');
-    if (!existsSync(sourceDbPath)) {
-        throw new Error(`Source database not found: ${sourceDbPath}`);
-    }
-    if (!existsSync(targetDbPath)) {
-        throw new Error(`Target database not found: ${targetDbPath}`);
-    }
-    // Use bun:sqlite for direct source DB access
-    // @ts-ignore - bun:sqlite module not found in types but works at runtime
-    const SqliteDatabase = (await import('bun:sqlite')).default;
-    const sourceDb = new SqliteDatabase(sourceDbPath, { readonly: true });
-    // Get target DB through the app's existing mechanism
-    const { db: targetDb, schema } = await getDbClient();
-    // Get all projects from source
-    const sourceProjects = sourceDb.query('SELECT * FROM projects').all();
-    // Map old project IDs to new project IDs
-    const projectIdMap = new Map();
-    for (const project of sourceProjects) {
-        // Check if project with same path exists in target
-        const existing = await targetDb.select()
-            .from(schema.projects)
-            .where((tbl, { eq }) => eq(tbl.path, project.path))
-            .limit(1);
-        if (existing.length > 0) {
-            projectIdMap.set(project.id, existing[0].id);
-        }
-        else {
-            // Create new project in target
-            const newId = randomUUID();
-            await targetDb.insert(schema.projects).values({
-                id: newId,
-                path: project.path,
-                name: project.name || 'migrated',
-                createdAt: new Date(),
-            });
-            projectIdMap.set(project.id, newId);
-        }
-    }
-    // Migrate memories
-    const sourceMemories = sourceDb.query('SELECT * FROM memories').all();
-    let memoriesCopied = 0;
-    for (const mem of sourceMemories) {
-        const oldProjectId = mem.project_id;
-        const newProjectId = projectIdMap.get(oldProjectId);
-        if (!newProjectId) {
-            console.warn(`Skipping memory ${mem.id}: no project mapping found`);
-            continue;
-        }
-        if (!dryRun) {
-            // Add 'imported' tag to track migrated memories
-            const existingTags = mem.tags ? JSON.parse(mem.tags) : [];
-            const newTags = [...existingTags, 'imported'];
-            await targetDb.insert(schema.memories).values({
-                id: randomUUID(),
-                projectId: newProjectId,
-                type: mem.type,
-                content: mem.content,
-                summary: mem.summary,
-                source: mem.source || 'migrated',
-                confidence: mem.confidence ?? 50,
-                confidenceLevel: mem.confidence_level || 'speculative',
-                tags: newTags,
-                metadata: { ...mem.metadata, migratedAt: new Date().toISOString(), originalId: mem.id },
-                isActive: mem.is_active ?? 1,
-                createdAt: mem.created_at ? new Date(mem.created_at * 1000) : new Date(),
-                updatedAt: new Date(),
-            });
-        }
-        memoriesCopied++;
-    }
-    // Migrate learnings (renamed from observations)
-    const sourceLearnings = sourceDb.query('SELECT * FROM learnings').all();
-    let learningsCopied = 0;
-    for (const learn of sourceLearnings) {
-        const oldProjectId = learn.project_id;
-        const newProjectId = projectIdMap.get(oldProjectId);
-        if (!newProjectId)
-            continue;
-        if (!dryRun) {
-            // Add is_imported flag to track migrated learnings
-            await targetDb.insert(schema.learnings).values({
-                id: randomUUID(),
-                projectId: newProjectId,
-                type: learn.type,
-                action: learn.action,
-                summary: learn.summary,
-                target: learn.target,
-                details: learn.details,
-                isImported: true,
-                createdAt: new Date(),
-            });
-        }
-        learningsCopied++;
-    }
-    // Migrate memory associations (simplified - skip for now)
-    const sourceAssoc = sourceDb.query('SELECT * FROM memory_associations').all();
-    let associationsCopied = 0;
-    if (!dryRun && sourceAssoc.length > 0) {
-        console.warn(`Note: ${sourceAssoc.length} associations not migrated (requires ID mapping)`);
-    }
-    // Close source DB
-    sourceDb.close();
-    // Delete source if requested
-    let sourceDeleted = false;
-    if (!dryRun && deleteSource && memoriesCopied > 0) {
-        // Implementation would delete the file
-        console.warn('Source deletion not implemented - requires manual removal');
-    }
-    return {
-        memoriesCopied,
-        observationsCopied: learningsCopied,
-        associationsCopied,
-        projectsMapped: projectIdMap.size,
-        sourceDeleted,
-        message: dryRun
-            ? 'Dry run complete - no changes made'
-            : `Successfully migrated ${memoriesCopied} memories, ${learningsCopied} learnings`
-    };
-}
-//# sourceMappingURL=migrate.js.map

package/dist/core/memory/normalization.d.ts

@@ -1,7 +0,0 @@
-/**
- * Memory normalization utilities
- * Shared between memories.ts and loader.ts to avoid circular dependencies
- */
-import type { MemoryRecord } from '../lib/types.js';
-export declare function normalizeMemory(row: any): MemoryRecord;
-//# sourceMappingURL=normalization.d.ts.map

package/dist/core/memory/normalization.js

@@ -1,26 +0,0 @@
-/**
- * Memory normalization utilities
- * Shared between memories.ts and loader.ts to avoid circular dependencies
- */
-import { deserializeTags, deserializeMetadata } from './serialization.js';
-import { normalizeTimestamp } from '../lib/utils.js';
-export function normalizeMemory(row) {
-    const tags = deserializeTags(row.tags ?? null);
-    const metadata = deserializeMetadata(row.metadata ?? null);
-    const createdAtStr = normalizeTimestamp(row.createdAt ?? row.created_at);
-    return {
-        id: row.id,
-        projectId: row.projectId ?? row.project_id ?? null,
-        type: row.type,
-        content: row.content,
-        summary: row.summary ?? null,
-        tags,
-        metadata,
-        createdAt: createdAtStr,
-        validFrom: row.validFrom ?? row.valid_from ?? null,
-        validTo: row.validTo ?? row.valid_to ?? null,
-        recordedAt: row.recordedAt ?? row.recorded_at ?? null,
-        confidenceLevel: row.confidenceLevel ?? row.confidence_level ?? null,
-    };
-}
-//# sourceMappingURL=normalization.js.map

package/dist/core/memory/path-strengthener.d.ts

@@ -1,39 +0,0 @@
-/**
- * Path Strengthener
- *
- * Strengthens association paths that led to successful retrievals and
- * weakens paths that led to irrelevant results. This implements the
- * "optimize" concept: the graph develops its own sense of relevance
- * over time based on actual usage patterns.
- *
- * A customer support agent's graph naturally strengthens paths through
- * product docs and refund policies while letting rarely-queried HR
- * edges decay.
- */
-export interface PathStrengthResult {
-    strengthened: number;
-    weakened: number;
-    pruned: number;
-}
-/**
- * Strengthen the association path between memories that were
- * retrieved together and found useful.
- */
-export declare function strengthenPath(memoryIds: string[], boostAmount?: number): Promise<number>;
-/**
- * Weaken association paths that led to irrelevant results.
- */
-export declare function weakenPath(memoryIds: string[], decayAmount?: number): Promise<number>;
-/**
- * Prune associations that have decayed below a threshold.
- */
-export declare function pruneWeakAssociations(minWeight?: number, maxAge?: number): Promise<number>;
-/**
- * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
- * prune dead associations, and derive implicit facts.
- */
-export declare function runPruneCycle(options?: {
-    minWeight?: number;
-    maxAge?: number;
-}): Promise<PathStrengthResult>;
-//# sourceMappingURL=path-strengthener.d.ts.map

package/dist/core/memory/path-strengthener.js

@@ -1,150 +0,0 @@
-/**
- * Path Strengthener
- *
- * Strengthens association paths that led to successful retrievals and
- * weakens paths that led to irrelevant results. This implements the
- * "optimize" concept: the graph develops its own sense of relevance
- * over time based on actual usage patterns.
- *
- * A customer support agent's graph naturally strengthens paths through
- * product docs and refund policies while letting rarely-queried HR
- * edges decay.
- */
-import { eq, and, or, sql } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { logger } from '../logger.js';
-/**
- * Strengthen the association path between memories that were
- * retrieved together and found useful.
- */
-export async function strengthenPath(memoryIds, boostAmount = 2) {
-    if (memoryIds.length < 2)
-        return 0;
-    const db = await getDb();
-    const schema = await getSchema();
-    let strengthened = 0;
-    // Generate all pairs
-    for (let i = 0; i < memoryIds.length; i++) {
-        for (let j = i + 1; j < memoryIds.length; j++) {
-            try {
-                // Check if association exists
-                const existing = await db
-                    .select()
-                    .from(schema.memoryAssociations)
-                    .where(or(and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]), eq(schema.memoryAssociations.toMemoryId, memoryIds[j])), and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]), eq(schema.memoryAssociations.toMemoryId, memoryIds[i]))))
-                    .limit(1);
-                if (existing.length > 0) {
-                    // Strengthen existing association
-                    await db
-                        .update(schema.memoryAssociations)
-                        .set({
-                        weight: sql `${schema.memoryAssociations.weight} + ${boostAmount}`,
-                        coactivationCount: sql `${schema.memoryAssociations.coactivationCount} + 1`,
-                        lastCoactivatedAt: new Date(),
-                    })
-                        .where(eq(schema.memoryAssociations.id, existing[0].id));
-                }
-                else {
-                    // Create new association
-                    await db.insert(schema.memoryAssociations).values({
-                        fromMemoryId: memoryIds[i],
-                        toMemoryId: memoryIds[j],
-                        associationType: 'co_occurred',
-                        weight: boostAmount,
-                        coactivationCount: 1,
-                        lastCoactivatedAt: new Date(),
-                    });
-                }
-                strengthened++;
-            }
-            catch (error) {
-                logger.debug('Error strengthening path', {
-                    from: memoryIds[i],
-                    to: memoryIds[j],
-                    error: error,
-                });
-            }
-        }
-    }
-    return strengthened;
-}
-/**
- * Weaken association paths that led to irrelevant results.
- */
-export async function weakenPath(memoryIds, decayAmount = 0.5) {
-    if (memoryIds.length < 2)
-        return 0;
-    const db = await getDb();
-    const schema = await getSchema();
-    let weakened = 0;
-    for (let i = 0; i < memoryIds.length; i++) {
-        for (let j = i + 1; j < memoryIds.length; j++) {
-            try {
-                const existing = await db
-                    .select()
-                    .from(schema.memoryAssociations)
-                    .where(or(and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[i]), eq(schema.memoryAssociations.toMemoryId, memoryIds[j])), and(eq(schema.memoryAssociations.fromMemoryId, memoryIds[j]), eq(schema.memoryAssociations.toMemoryId, memoryIds[i]))))
-                    .limit(1);
-                if (existing.length > 0) {
-                    // Weaken but don't remove (minimum weight of 1)
-                    await db
-                        .update(schema.memoryAssociations)
-                        .set({
-                        weight: sql `GREATEST(${schema.memoryAssociations.weight} - ${decayAmount}, 1)`,
-                    })
-                        .where(eq(schema.memoryAssociations.id, existing[0].id));
-                    weakened++;
-                }
-            }
-            catch (error) {
-                logger.debug('Error weakening path', {
-                    from: memoryIds[i],
-                    to: memoryIds[j],
-                    error: error,
-                });
-            }
-        }
-    }
-    return weakened;
-}
-/**
- * Prune associations that have decayed below a threshold.
- */
-export async function pruneWeakAssociations(minWeight = 2, maxAge = 90 // days
-) {
-    const db = await getDb();
-    const schema = await getSchema();
-    const cutoffDate = new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - maxAge);
-    try {
-        // Delete associations that are weak AND old
-        const result = await db
-            .delete(schema.memoryAssociations)
-            .where(and(sql `${schema.memoryAssociations.weight} < ${minWeight}`, sql `${schema.memoryAssociations.lastCoactivatedAt} < ${cutoffDate}`));
-        const pruned = result?.rowCount ?? 0;
-        logger.info('Pruned weak associations', { pruned, minWeight, maxAge });
-        return pruned;
-    }
-    catch (error) {
-        logger.error('Error pruning weak associations', { error: error });
-        return 0;
-    }
-}
-/**
- * Run a full optimize cycle: strengthen useful paths, weaken unused ones,
- * prune dead associations, and derive implicit facts.
- */
-export async function runPruneCycle(options) {
-    const { minWeight = 2, maxAge = 90 } = options || {};
-    logger.info('Starting prune cycle', { minWeight, maxAge });
-    // Step 1: Prune weak associations
-    const pruned = await pruneWeakAssociations(minWeight, maxAge);
-    logger.info('Prune cycle completed', { pruned });
-    return {
-        strengthened: 0, // Strengthening happens via retrieval feedback
-        weakened: 0, // Weakening happens via retrieval feedback
-        pruned,
-    };
-}
-//# sourceMappingURL=path-strengthener.js.map

package/dist/core/memory/progressive-disclosure.d.ts

@@ -1,43 +0,0 @@
-export interface LightweightIndex {
-    id: string;
-    memoryId: string;
-    contentHash: string;
-    contentPreview: string;
-    keyTerms: string[];
-    category: string;
-    importance: number;
-    createdAt: Date;
-}
-export interface MemoryPreview {
-    id: string;
-    type: string;
-    contentPreview: string;
-    keyTerms: string[];
-    category: string;
-    importance: number;
-    lastAccessedAt?: Date;
-}
-export interface FullMemoryLoad {
-    id: string;
-    content: string;
-    summary?: string;
-    tags: string[];
-    metadata?: Record<string, unknown>;
-}
-export interface TokenBudgetStatus {
-    budget: number;
-    used: number;
-    remaining: number;
-    loadedCount: number;
-    preloadCount: number;
-}
-export declare function createLightweightIndex(memoryId: string, content: string, category: string, importance: number): Promise<LightweightIndex>;
-export declare function searchLightweightIndices(projectId: string, query: string, limit?: number): Promise<MemoryPreview[]>;
-export declare function loadFullMemory(memoryId: string): Promise<FullMemoryLoad | null>;
-export declare function estimateTokenCount(text: string): Promise<number>;
-export declare function allocateTokenBudget(sessionId: string, budget: number): Promise<TokenBudgetStatus>;
-export declare function preloadCandidateMemories(sessionId: string, projectId: string, budget: number, excludeLoadedIds: string[]): Promise<string[]>;
-export declare function getPreloadCandidates(sessionId: string): Promise<MemoryPreview[]>;
-export declare function updateIndexImportance(memoryId: string, importance: number): Promise<void>;
-export declare function deleteLightweightIndex(memoryId: string): Promise<void>;
-//# sourceMappingURL=progressive-disclosure.d.ts.map

package/dist/core/memory/progressive-disclosure.js

@@ -1,280 +0,0 @@
-import { randomUUID } from 'crypto';
-import { eq, desc, and, sql } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../storage/database.js';
-const PREVIEW_TOKENS = 50;
-const MAX_PRELOAD_CANDIDATES = 20;
-const TOKEN_ESTIMATE_CHARS = 4;
-export async function createLightweightIndex(memoryId, content, category, importance) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const contentHash = hashContent(content);
-    const contentPreview = extractPreview(content);
-    const keyTerms = extractKeyTerms(content);
-    const index = {
-        id: randomUUID(),
-        memoryId,
-        contentHash,
-        contentPreview,
-        keyTerms,
-        category,
-        importance,
-        createdAt: new Date(),
-    };
-    await db.insert(schema.lightweightMemoryIndices).values({
-        id: index.id,
-        memoryId: index.memoryId,
-        contentHash: index.contentHash,
-        contentPreview: index.contentPreview,
-        keyTerms: JSON.stringify(index.keyTerms),
-        category: index.category,
-        importanceScore: index.importance,
-        createdAt: index.createdAt,
-    });
-    return index;
-}
-export async function searchLightweightIndices(projectId, query, limit = 10) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const queryLower = query.toLowerCase();
-    const queryTerms = queryLower.split(/\s+/).filter((t) => t.length > 2);
-    const results = await db
-        .select({
-        id: schema.lightweightMemoryIndices.id,
-        memoryId: schema.lightweightMemoryIndices.memoryId,
-        contentPreview: schema.lightweightMemoryIndices.contentPreview,
-        keyTerms: schema.lightweightMemoryIndices.keyTerms,
-        category: schema.lightweightMemoryIndices.category,
-        importanceScore: schema.lightweightMemoryIndices.importanceScore,
-        lastAccessedAt: schema.memories.lastAccessedAt,
-    })
-        .from(schema.lightweightMemoryIndices)
-        .leftJoin(schema.memories, eq(schema.lightweightMemoryIndices.memoryId, schema.memories.id))
-        .where(eq(schema.lightweightMemoryIndices.memoryId, schema.memories.id))
-        .limit(limit * 2);
-    const scored = results.map((row) => {
-        let score = row.importanceScore ?? 50;
-        const keyTerms = typeof row.keyTerms === 'string'
-            ? JSON.parse(row.keyTerms)
-            : row.keyTerms ?? [];
-        const termsLower = keyTerms.map((t) => t.toLowerCase());
-        for (const term of queryTerms) {
-            if (row.contentPreview.toLowerCase().includes(term)) {
-                score += 10;
-            }
-            if (termsLower.some((t) => t.includes(term))) {
-                score += 15;
-            }
-        }
-        return {
-            id: row.id,
-            memoryId: row.memoryId,
-            contentPreview: row.contentPreview,
-            keyTerms,
-            category: row.category,
-            importance: row.importanceScore ?? 50,
-            lastAccessedAt: row.lastAccessedAt,
-            score,
-        };
-    });
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, limit).map((item) => ({
-        id: item.memoryId,
-        type: 'preview',
-        contentPreview: item.contentPreview,
-        keyTerms: item.keyTerms,
-        category: item.category,
-        importance: item.importance,
-        lastAccessedAt: item.lastAccessedAt,
-    }));
-}
-export async function loadFullMemory(memoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const rows = await db
-        .select()
-        .from(schema.memories)
-        .where(eq(schema.memories.id, memoryId))
-        .limit(1);
-    if (rows.length === 0)
-        return null;
-    const row = rows[0];
-    return {
-        id: row.id,
-        content: row.content,
-        summary: row.summary ?? undefined,
-        tags: Array.isArray(row.tags) ? row.tags : [],
-        metadata: row.metadata ?? undefined,
-    };
-}
-export async function estimateTokenCount(text) {
-    return Math.ceil(text.length / TOKEN_ESTIMATE_CHARS);
-}
-export async function allocateTokenBudget(sessionId, budget) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const [session] = await db
-        .select()
-        .from(schema.contextPagingSessions)
-        .where(eq(schema.contextPagingSessions.sessionId, sessionId))
-        .limit(1);
-    if (!session) {
-        return {
-            budget,
-            used: 0,
-            remaining: budget,
-            loadedCount: 0,
-            preloadCount: 0,
-        };
-    }
-    const tokensUsed = session.tokensUsed ?? 0;
-    const loadedCount = session.loadedMemoryIds?.length ?? 0;
-    const preloadCount = session.preloadCandidateIds?.length ?? 0;
-    return {
-        budget,
-        used: tokensUsed,
-        remaining: Math.max(0, budget - tokensUsed),
-        loadedCount,
-        preloadCount,
-    };
-}
-export async function preloadCandidateMemories(sessionId, projectId, budget, excludeLoadedIds) {
-    const status = await allocateTokenBudget(sessionId, budget);
-    const availableTokens = status.remaining;
-    if (availableTokens < PREVIEW_TOKENS * 2) {
-        return [];
-    }
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const rows = await db
-        .select({
-        id: schema.memories.id,
-        content: schema.memories.content,
-        importanceScore: schema.memories.importanceScore,
-        lastAccessedAt: schema.memories.lastAccessedAt,
-    })
-        .from(schema.memories)
-        .where(and(eq(schema.memories.projectId, projectId), eq(schema.memories.isActive, true), excludeLoadedIds.length > 0
-        ? sql `${schema.memories.id} NOT IN (${excludeLoadedIds.map(id => `'${id.replace(/'/g, "''")}'`).join(',')})`
-        : sql `TRUE`))
-        .orderBy(desc(schema.memories.importanceScore), desc(schema.memories.lastAccessedAt))
-        .limit(MAX_PRELOAD_CANDIDATES);
-    const candidates = [];
-    let tokensForPreload = Math.min(availableTokens - PREVIEW_TOKENS, availableTokens * 0.3);
-    for (const row of rows) {
-        const tokens = await estimateTokenCount(row.content ?? '');
-        if (tokens <= tokensForPreload) {
-            candidates.push(row.id);
-            tokensForPreload -= tokens;
-        }
-        if (candidates.length >= 5)
-            break;
-    }
-    await db
-        .update(schema.contextPagingSessions)
-        .set({
-        preloadCandidateIds: candidates,
-        updatedAt: new Date(),
-    })
-        .where(eq(schema.contextPagingSessions.sessionId, sessionId));
-    return candidates;
-}
-export async function getPreloadCandidates(sessionId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const [session] = await db
-        .select()
-        .from(schema.contextPagingSessions)
-        .where(eq(schema.contextPagingSessions.sessionId, sessionId))
-        .limit(1);
-    if (!session)
-        return [];
-    const candidateIds = session.preloadCandidateIds ?? [];
-    if (candidateIds.length === 0)
-        return [];
-    const previews = [];
-    for (const memoryId of candidateIds.slice(0, 5)) {
-        const [index] = await db
-            .select()
-            .from(schema.lightweightMemoryIndices)
-            .where(eq(schema.lightweightMemoryIndices.memoryId, memoryId))
-            .limit(1);
-        if (index) {
-            const keyTerms = typeof index.keyTerms === 'string'
-                ? JSON.parse(index.keyTerms)
-                : index.keyTerms ?? [];
-            previews.push({
-                id: index.memoryId,
-                type: 'preload',
-                contentPreview: index.contentPreview,
-                keyTerms,
-                category: index.category,
-                importance: index.importanceScore ?? 50,
-            });
-        }
-    }
-    return previews;
-}
-export async function updateIndexImportance(memoryId, importance) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    await db
-        .update(schema.lightweightMemoryIndices)
-        .set({
-        importanceScore: importance,
-    })
-        .where(eq(schema.lightweightMemoryIndices.memoryId, memoryId));
-}
-export async function deleteLightweightIndex(memoryId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    await db
-        .delete(schema.lightweightMemoryIndices)
-        .where(eq(schema.lightweightMemoryIndices.memoryId, memoryId));
-}
-function hashContent(content) {
-    let hash = 0;
-    for (let i = 0; i < content.length; i++) {
-        const char = content.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash;
-    }
-    return Math.abs(hash).toString(36);
-}
-function extractPreview(content) {
-    const firstPeriod = content.indexOf('.');
-    const firstNewline = content.indexOf('\n');
-    let endIndex = content.length;
-    if (firstPeriod > 0 && firstPeriod < 100) {
-        endIndex = firstPeriod + 1;
-    }
-    else if (firstNewline > 0 && firstNewline < 100) {
-        endIndex = firstNewline;
-    }
-    return content.substring(0, Math.min(endIndex, 150)).trim();
-}
-function extractKeyTerms(content) {
-    const words = content.toLowerCase()
-        .replace(/[^\w\s]/g, ' ')
-        .split(/\s+/)
-        .filter((w) => w.length > 3);
-    const stopWords = new Set([
-        'this', 'that', 'with', 'from', 'have', 'been', 'were', 'they',
-        'their', 'which', 'about', 'would', 'could', 'should', 'there',
-        'what', 'when', 'where', 'who', 'will', 'just', 'like', 'into',
-        'than', 'then', 'both', 'each', 'more', 'most', 'other', 'some',
-        'such', 'only', 'over', 'very', 'also', 'back', 'after', 'being',
-    ]);
-    const termCounts = {};
-    for (const word of words) {
-        if (!stopWords.has(word) && !/^\d+$/.test(word)) {
-            termCounts[word] = (termCounts[word] ?? 0) + 1;
-        }
-    }
-    return Object.entries(termCounts)
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, 5)
-        .map(([term]) => term);
-}
-//# sourceMappingURL=progressive-disclosure.js.map