squish-memory 1.1.5 → 1.2.1

package/dist/core/ingestion/agent-memory.js

@@ -1,109 +0,0 @@
-/**
- * Agent-Aware Memory Management
- * Provides agent isolation and visibility rules
- */
-import { and, eq } from 'drizzle-orm';
-import { randomUUID } from 'crypto';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { config } from '../../config.js';
-import { getEmbedding } from '../embeddings.js';
-import { logger } from '../logger.js';
-/**
- * Store a memory with agent context
- */
-export async function storeAgentMemory(content, context, options = {}) {
-    if (!config.agentIsolationEnabled) {
-        // Fall back to standard memory storage
-        return await storeStandardMemory(content, options);
-    }
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        const memoryId = randomUUID();
-        const embedding = await getEmbedding(content);
-        const visibilityScope = options.visibilityScope || config.defaultVisibilityScope;
-        // Determine scopes based on visibility
-        const readScope = calculateReadScope(context, visibilityScope);
-        const writeScope = [`agent:${context.agentId}`];
-        await db.insert(schema.memories).values({
-            id: memoryId,
-            content,
-            type: options.type || 'observation',
-            sector: options.sector || 'episodic',
-            agentId: context.agentId,
-            agentRole: context.agentRole || 'general',
-            userId: context.userId || null,
-            projectId: context.projectId || null,
-            visibilityScope,
-            writeScope,
-            readScope,
-            tags: options.tags || [],
-            metadata: options.metadata || null,
-            embedding: embedding || null,
-            confidence: 100,
-            relevanceScore: 50,
-            createdAt: new Date(),
-            updatedAt: new Date(),
-        });
-        return memoryId;
-    }
-    catch (error) {
-        logger.error('Error storing agent memory', error);
-        throw error;
-    }
-}
-// Helper Functions
-function calculateReadScope(context, visibility) {
-    switch (visibility) {
-        case 'private':
-            return [`agent:${context.agentId}`];
-        case 'project':
-            return [`agent:${context.agentId}`, `project:${context.projectId || '*'}`];
-        case 'team':
-            return [`agent:${context.agentId}`, 'team:*'];
-        case 'global':
-            return ['*'];
-        default:
-            return [`agent:${context.agentId}`];
-    }
-}
-async function storeStandardMemory(content, options = {}) {
-    // Fallback to standard memory storage if agent isolation is disabled
-    const db = await getDb();
-    const schema = await getSchema();
-    const memoryId = randomUUID();
-    const embedding = await getEmbedding(content);
-    await db.insert(schema.memories).values({
-        id: memoryId,
-        content,
-        type: options.type || 'observation',
-        sector: options.sector || 'episodic',
-        tags: options.tags || [],
-        metadata: options.metadata || null,
-        embedding: embedding || null,
-        confidence: 100,
-        relevanceScore: 50,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-    });
-    return memoryId;
-}
-async function searchStandardMemories(query, options = {}) {
-    // Fallback to standard memory search if agent isolation is disabled
-    const db = await getDb();
-    const schema = await getSchema();
-    const limit = Math.min(options.limit || 10, 100);
-    let where = undefined;
-    if (options.type) {
-        where = eq(schema.memories.type, options.type);
-    }
-    return await db
-        .select()
-        .from(schema.memories)
-        .where(where
-        ? and(where, schema.memories.content.ilike(`%${query}%`))
-        : schema.memories.content.ilike(`%${query}%`))
-        .limit(limit);
-}
-//# sourceMappingURL=agent-memory.js.map

package/dist/core/ingestion/core-memory.d.ts

@@ -1,78 +0,0 @@
-/**
- * Core Memory Service - Always-in-context memory (Tier 1)
- *
- * Small, persistent, always-visible memory block (< 2KB total).
- * This memory is automatically injected into every agent interaction.
- */
-type CoreMemorySection = 'persona' | 'user_info' | 'project_context' | 'working_notes';
-interface CoreMemoryContent {
-    persona: string;
-    user_info: string;
-    project_context: string;
-    working_notes: string;
-}
-/**
- * Initialize core memory for a project
- */
-export declare function initializeCoreMemory(projectId: string, userId?: string): Promise<void>;
-/**
- * Get all core memory sections for a project
- */
-export declare function getCoreMemory(projectId: string): Promise<CoreMemoryContent>;
-/**
- * Get a specific core memory section
- */
-export declare function getCoreMemorySection(projectId: string, section: CoreMemorySection): Promise<string>;
-/**
- * Update (replace) a core memory section
- */
-export declare function editCoreMemorySection(projectId: string, section: CoreMemorySection, content: string): Promise<{
-    success: boolean;
-    message?: string;
-    sizeBytes?: number;
-    tokensEstimate?: number;
-}>;
-/**
- * Append content to a core memory section
- */
-export declare function appendCoreMemorySection(projectId: string, section: CoreMemorySection, text: string): Promise<{
-    success: boolean;
-    message?: string;
-    sizeBytes?: number;
-}>;
-/**
- * Replace text within a core memory section
- */
-export declare function replaceCoreMemoryText(projectId: string, section: CoreMemorySection, oldText: string, newText: string): Promise<{
-    success: boolean;
-    message?: string;
-    sizeBytes?: number;
-}>;
-/**
- * Get core memory stats
- */
-export declare function getCoreMemoryStats(projectId: string): Promise<{
-    totalBytes: number;
-    totalTokens: number;
-    maxBytes: number;
-    maxTokens: number;
-    usagePercent: number;
-    tokenUsagePercent: number;
-    sections: Array<{
-        section: string;
-        sizeBytes: number;
-        tokensEstimate: number;
-        version: number;
-        updatedAt: Date;
-    }>;
-}>;
-/**
- * Estimate token count from text (rough approximation: 1 token ≈ 4 chars)
- */
-export declare function estimateTokens(text: string): number;
-/**
- * Get core memory formatted for context injection
- */
-export declare function formatCoreMemoryForInjection(projectId: string): Promise<string>;
-export {};
-//# sourceMappingURL=core-memory.d.ts.map

package/dist/core/ingestion/core-memory.js

@@ -1,226 +0,0 @@
-/**
- * Core Memory Service - Always-in-context memory (Tier 1)
- *
- * Small, persistent, always-visible memory block (< 2KB total).
- * This memory is automatically injected into every agent interaction.
- */
-import { eq, and, sql } 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';
-// Use configurable limits from environment
-const MAX_TOTAL_SIZE_BYTES = config.coreMemoryTotalBytes;
-const MAX_SECTION_SIZE_BYTES = config.coreMemorySectionBytes;
-/**
- * Initialize core memory for a project
- */
-export async function initializeCoreMemory(projectId, userId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { coreMemory } = schema;
-    const sections = ['persona', 'user_info', 'project_context', 'working_notes'];
-    for (const section of sections) {
-        const existing = await db
-            .select()
-            .from(coreMemory)
-            .where(and(eq(coreMemory.projectId, projectId), eq(coreMemory.section, section)))
-            .limit(1);
-        if (existing.length === 0) {
-            await db.insert(coreMemory).values({
-                projectId: projectId,
-                userId: userId,
-                section,
-                content: '',
-                sizeBytes: 0,
-                version: 1,
-            });
-        }
-    }
-}
-/**
- * Get all core memory sections for a project
- */
-export async function getCoreMemory(projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { coreMemory } = schema;
-    const sections = await db
-        .select()
-        .from(coreMemory)
-        .where(eq(coreMemory.projectId, projectId));
-    const content = {
-        persona: '',
-        user_info: '',
-        project_context: '',
-        working_notes: '',
-    };
-    for (const section of sections) {
-        const key = section.section;
-        content[key] = section.content || '';
-    }
-    return content;
-}
-/**
- * Get a specific core memory section
- */
-export async function getCoreMemorySection(projectId, section) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { coreMemory } = schema;
-    const result = await db
-        .select()
-        .from(coreMemory)
-        .where(and(eq(coreMemory.projectId, projectId), eq(coreMemory.section, section)))
-        .limit(1);
-    return result[0]?.content || '';
-}
-/**
- * Update (replace) a core memory section
- */
-export async function editCoreMemorySection(projectId, section, content) {
-    const sizeBytes = Buffer.byteLength(content, 'utf8');
-    const tokensEstimate = estimateTokens(content);
-    // Check section size limit
-    if (sizeBytes > MAX_SECTION_SIZE_BYTES) {
-        return {
-            success: false,
-            message: `Content exceeds section limit of ${MAX_SECTION_SIZE_BYTES} bytes (got ${sizeBytes} bytes)`,
-        };
-    }
-    // Check total size limit
-    const totalSize = await getTotalCoreMemorySize(projectId, section, sizeBytes);
-    if (totalSize > MAX_TOTAL_SIZE_BYTES) {
-        return {
-            success: false,
-            message: `Total core memory would exceed ${MAX_TOTAL_SIZE_BYTES} bytes (would be ${totalSize} bytes)`,
-        };
-    }
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { coreMemory } = schema;
-    await db
-        .update(coreMemory)
-        .set({
-        content,
-        sizeBytes,
-        tokensEstimate,
-        version: sql `${coreMemory.version} + 1`,
-        updatedAt: new Date(),
-    })
-        .where(and(eq(coreMemory.projectId, projectId), eq(coreMemory.section, section)));
-    return { success: true, sizeBytes, tokensEstimate };
-}
-/**
- * Append content to a core memory section
- */
-export async function appendCoreMemorySection(projectId, section, text) {
-    const currentContent = await getCoreMemorySection(projectId, section);
-    const newContent = currentContent ? `${currentContent}\n${text}` : text;
-    return editCoreMemorySection(projectId, section, newContent);
-}
-/**
- * Replace text within a core memory section
- */
-export async function replaceCoreMemoryText(projectId, section, oldText, newText) {
-    const currentContent = await getCoreMemorySection(projectId, section);
-    if (!currentContent.includes(oldText)) {
-        return {
-            success: false,
-            message: `Text "${oldText}" not found in section "${section}"`,
-        };
-    }
-    const newContent = currentContent.replace(oldText, newText);
-    return editCoreMemorySection(projectId, section, newContent);
-}
-/**
- * Get total size of core memory (excluding one section if calculating new size)
- */
-async function getTotalCoreMemorySize(projectId, excludeSection, newSectionSize) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { coreMemory } = schema;
-    const sections = await db
-        .select()
-        .from(coreMemory)
-        .where(eq(coreMemory.projectId, projectId));
-    let total = 0;
-    for (const section of sections) {
-        if (section.section === excludeSection) {
-            total += newSectionSize || 0;
-        }
-        else {
-            total += section.sizeBytes || 0;
-        }
-    }
-    return total;
-}
-/**
- * Get core memory stats
- */
-export async function getCoreMemoryStats(projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { coreMemory } = schema;
-    const sections = await db
-        .select()
-        .from(coreMemory)
-        .where(eq(coreMemory.projectId, projectId));
-    const totalBytes = sections.reduce((sum, s) => sum + (s.sizeBytes || 0), 0);
-    const totalTokens = sections.reduce((sum, s) => sum + (s.tokensEstimate || 0), 0);
-    // Estimate max tokens from max bytes (rough approximation: 1 token ≈ 4 chars)
-    const maxTokens = Math.floor(MAX_TOTAL_SIZE_BYTES / 4);
-    return {
-        totalBytes,
-        totalTokens,
-        maxBytes: MAX_TOTAL_SIZE_BYTES,
-        maxTokens,
-        usagePercent: (totalBytes / MAX_TOTAL_SIZE_BYTES) * 100,
-        tokenUsagePercent: (totalTokens / maxTokens) * 100,
-        sections: sections.map((s) => ({
-            section: s.section,
-            sizeBytes: s.sizeBytes || 0,
-            tokensEstimate: s.tokensEstimate || 0,
-            version: s.version || 1,
-            updatedAt: s.updatedAt,
-        })),
-    };
-}
-/**
- * Estimate token count from text (rough approximation: 1 token ≈ 4 chars)
- */
-export function estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-}
-/**
- * Get core memory formatted for context injection
- */
-export async function formatCoreMemoryForInjection(projectId) {
-    const content = await getCoreMemory(projectId);
-    const stats = await getCoreMemoryStats(projectId);
-    let formatted = `# Core Memory (Always-In-Context)\n\n`;
-    if (content.persona) {
-        formatted += `## Agent Persona\n${content.persona}\n\n`;
-    }
-    if (content.user_info) {
-        formatted += `## User Information\n${content.user_info}\n\n`;
-    }
-    if (content.project_context) {
-        formatted += `## Project Context\n${content.project_context}\n\n`;
-    }
-    if (content.working_notes) {
-        formatted += `## Working Notes\n${content.working_notes}\n\n`;
-    }
-    formatted += `---\n`;
-    formatted += `Core Memory Usage:\n`;
-    formatted += `- Bytes: ${stats.totalBytes}/${stats.maxBytes} (${stats.usagePercent.toFixed(1)}%)\n`;
-    formatted += `- Tokens: ~${stats.totalTokens}/${stats.maxTokens} (${stats.tokenUsagePercent.toFixed(1)}%)\n\n`;
-    // Add tool usage hints for agent-driven retrieval
-    formatted += `### Memory Tools Available\n`;
-    formatted += `When you need to recall information or store something important, use these tools:\n`;
-    formatted += `- **Search**: Use \`/squish:search\` to find stored memories matching a query\n`;
-    formatted += `- **Store**: Use \`/squish:remember\` to save new information for future use\n`;
-    formatted += `- **Update Core Memory**: Use \`/squish:core-memory\` to edit this always-visible memory\n`;
-    return formatted;
-}
-//# sourceMappingURL=core-memory.js.map

package/dist/core/ingestion/learnings.d.ts

@@ -1,57 +0,0 @@
-/**
- * Learnings Module
- * Agent learnings: success, failure, fix, insight
- * With auto-linking to similar memories and learnings
- */
-export type LearningType = 'success' | 'failure' | 'fix' | 'insight';
-export interface LearningInput {
-    type: LearningType;
-    content: string;
-    context?: string;
-    action?: string;
-    target?: string;
-    project?: string;
-    memoryId?: string;
-    autoLink?: boolean;
-}
-export interface LearningRecord {
-    id: string;
-    projectId?: string | null;
-    conversationId?: string | null;
-    type: LearningType;
-    action: string;
-    target?: string | null;
-    summary: string;
-    details?: Record<string, unknown> | null;
-    memoryId?: string | null;
-    isImported?: boolean;
-    createdAt?: string | null;
-}
-/**
- * Create a learning and optionally auto-link to similar memories/learnings
- */
-export declare function createLearning(input: LearningInput): Promise<LearningRecord>;
-/**
- * Get learnings for a project
- */
-export declare function getLearnings(projectPath: string, limit: number): Promise<LearningRecord[]>;
-/**
- * Get recent learnings
- */
-export declare function getRecentLearnings(projectPath: string, limit?: number): Promise<LearningRecord[]>;
-/**
- * Get learning by ID
- */
-export declare function getLearningById(learningId: string): Promise<LearningRecord | null>;
-/**
- * Get learnings linked to a specific memory
- */
-export declare function getLearningsForMemory(memoryId: string): Promise<LearningRecord[]>;
-/**
- * Delete a learning
- */
-export declare function deleteLearning(learningId: string): Promise<boolean>;
-export declare const getObservations: typeof getLearnings;
-export declare const getRecentObservations: typeof getRecentLearnings;
-export declare const getObservationById: typeof getLearningById;
-//# sourceMappingURL=learnings.d.ts.map

package/dist/core/ingestion/learnings.js

@@ -1,202 +0,0 @@
-/**
- * Learnings Module
- * Agent learnings: success, failure, fix, insight
- * With auto-linking to similar memories and learnings
- */
-import { randomUUID } from 'crypto';
-import { desc, eq } from 'drizzle-orm';
-import { getEmbedding } from '../embeddings.js';
-import { getOrCreateProject, requireProject } from '../projects.js';
-import { serializeMetadata, deserializeMetadata } from '../memory/serialization.js';
-import { normalizeTimestamp, prepareEmbedding } from '../lib/utils.js';
-import { logger } from '../logger.js';
-import { getDbClient } from '../lib/db-client.js';
-import { createAssociation } from '../associations.js';
-import { search } from '../memory/memories.js';
-/**
- * Create a learning and optionally auto-link to similar memories/learnings
- */
-export async function createLearning(input) {
-    const { db, schema } = await getDbClient();
-    const project = await getOrCreateProject(input.project);
-    const embedding = await getEmbedding(input.content);
-    const id = randomUUID();
-    const learningType = input.type;
-    const autoLink = input.autoLink !== false; // default true
-    // Build details with learning metadata
-    const details = serializeMetadata({
-        learningType: learningType,
-        learningContent: input.content,
-        learningContext: input.context,
-    });
-    const embeddingValues = prepareEmbedding(embedding);
-    // Insert the learning
-    await db.insert(schema.learnings).values({
-        id,
-        projectId: project?.id ?? null,
-        type: learningType,
-        action: input.action ?? input.content,
-        summary: input.context || input.content,
-        target: input.target ?? null,
-        details,
-        memoryId: input.memoryId ?? null,
-        ...embeddingValues,
-        createdAt: new Date(),
-    });
-    // If memoryId provided, create bidirectional link
-    if (input.memoryId) {
-        await createAssociation(input.memoryId, // from memory
-        id, // to learning
-        'relates_to', 1);
-    }
-    // Auto-link to similar memories and learnings (if enabled)
-    if (autoLink) {
-        await autoLinkLearning(id, input.content, project?.id ?? null);
-    }
-    return {
-        id,
-        projectId: project?.id ?? null,
-        conversationId: null,
-        type: learningType,
-        action: input.action ?? input.content,
-        target: input.target ?? null,
-        summary: input.context || input.content,
-        details: { learningType: learningType, learningContent: input.content, learningContext: input.context },
-        memoryId: input.memoryId ?? null,
-        createdAt: new Date().toISOString(),
-    };
-}
-/**
- * Auto-link a learning to similar memories above threshold
- */
-async function autoLinkLearning(learningId, content, projectId) {
-    const SIMILARITY_THRESHOLD = 0.85;
-    const MAX_LINKS = 5;
-    if (!projectId)
-        return;
-    try {
-        // Search for similar memories using the search function
-        const similarMemories = await search({
-            query: content,
-            limit: MAX_LINKS,
-        });
-        // Filter by similarity threshold
-        const relevantMemories = similarMemories.filter((m) => (m.similarity ?? 0) >= SIMILARITY_THRESHOLD);
-        // Create associations with memories
-        for (const mem of relevantMemories) {
-            await createAssociation(learningId, // from learning
-            mem.id, // to memory
-            'relates_to', mem.similarity ?? 0.9);
-        }
-        logger.info(`Auto-linked learning ${learningId} to ${relevantMemories.length} memories`);
-    }
-    catch (error) {
-        logger.error('Error in auto-linking:', error);
-        // Don't fail learning creation if auto-link fails
-    }
-}
-/**
- * Get learnings for a project
- */
-export async function getLearnings(projectPath, limit) {
-    try {
-        const { db, schema } = await getDbClient();
-        const project = await requireProject(projectPath);
-        const rows = await db.select().from(schema.learnings)
-            .where(eq(schema.learnings.projectId, project.id))
-            .orderBy(desc(schema.learnings.createdAt))
-            .limit(limit);
-        return rows.map((row) => normalizeLearning(row));
-    }
-    catch (error) {
-        throw error;
-    }
-}
-/**
- * Get recent learnings
- */
-export async function getRecentLearnings(projectPath, limit = 10) {
-    try {
-        const { db, schema } = await getDbClient();
-        const project = await requireProject(projectPath);
-        const rows = await db.select().from(schema.learnings)
-            .where(eq(schema.learnings.projectId, project.id))
-            .orderBy(desc(schema.learnings.createdAt))
-            .limit(limit);
-        return rows.map((row) => normalizeLearning(row));
-    }
-    catch (error) {
-        logger.error('Error getting recent learnings', error);
-        throw error;
-    }
-}
-/**
- * Get learning by ID
- */
-export async function getLearningById(learningId) {
-    try {
-        const { db, schema } = await getDbClient();
-        const rows = await db.select().from(schema.learnings)
-            .where(eq(schema.learnings.id, learningId))
-            .limit(1);
-        if (rows.length === 0)
-            return null;
-        return normalizeLearning(rows[0]);
-    }
-    catch (error) {
-        logger.error('Error getting learning', error);
-        throw error;
-    }
-}
-/**
- * Get learnings linked to a specific memory
- */
-export async function getLearningsForMemory(memoryId) {
-    try {
-        const { db, schema } = await getDbClient();
-        const rows = await db.select().from(schema.learnings)
-            .where(eq(schema.learnings.memoryId, memoryId))
-            .orderBy(desc(schema.learnings.createdAt));
-        return rows.map((row) => normalizeLearning(row));
-    }
-    catch (error) {
-        logger.error('Error getting learnings for memory', error);
-        throw error;
-    }
-}
-/**
- * Delete a learning
- */
-export async function deleteLearning(learningId) {
-    try {
-        const { db, schema } = await getDbClient();
-        await db.delete(schema.learnings)
-            .where(eq(schema.learnings.id, learningId));
-        return true;
-    }
-    catch (error) {
-        logger.error('Error deleting learning', error);
-        return false;
-    }
-}
-function normalizeLearning(row) {
-    const details = deserializeMetadata(row.details ?? null);
-    return {
-        id: row.id,
-        projectId: row.projectId ?? row.project_id ?? null,
-        conversationId: row.conversationId ?? row.conversation_id ?? null,
-        type: row.type,
-        action: row.action,
-        target: row.target ?? null,
-        summary: row.summary,
-        details,
-        memoryId: row.memoryId ?? row.memory_id ?? null,
-        isImported: row.isImported ?? row.is_imported ?? false,
-        createdAt: normalizeTimestamp(row.createdAt ?? row.created_at),
-    };
-}
-// Backwards compatibility aliases
-export const getObservations = getLearnings;
-export const getRecentObservations = getRecentLearnings;
-export const getObservationById = getLearningById;
-//# sourceMappingURL=learnings.js.map

package/dist/core/layers/generator.d.ts

@@ -1,25 +0,0 @@
-/** Layer Extractor - Creates L0/L1 truncated layers for token-efficient hierarchical retrieval */
-export interface LayerGenerationConfig {
-    l0MaxLength?: number;
-    l1MaxLength?: number;
-    autoGenerate?: boolean;
-}
-export interface LayerGenerationResult {
-    l0?: string;
-    l1?: string;
-    l2?: string;
-    tokenCounts: {
-        l0: number;
-        l1: number;
-        l2: number;
-    };
-}
-/**
- * Extract L0/L1/L2 layers for content via truncation
- */
-export declare function extractLayers(content: string, config?: LayerGenerationConfig): Promise<LayerGenerationResult>;
-/**
- * Check if content should have layers auto-extracted
- */
-export declare function shouldAutoGenerate(contentLength: number): boolean;
-//# sourceMappingURL=generator.d.ts.map