squish-memory 1.0.2 → 1.1.5

package/dist/core/hooks/auto-tagger.js

@@ -0,0 +1,155 @@
+/**
+ * Auto-Tagger - Infer tags from context
+ *
+ * Analyzes tool input/output to automatically infer relevant tags.
+ * Uses pattern matching to classify actions.
+ */
+/**
+ * Infer tags based on tool, input, and content
+ */
+export function inferTags(toolName, toolInput, content) {
+    const tags = ['hook', 'autocapture']; // Always add these
+    const tool = toolName.toLowerCase();
+    const inputStr = JSON.stringify(toolInput).toLowerCase();
+    const contentLower = content.toLowerCase();
+    // File type tags
+    if (tool === 'write' || tool === 'edit') {
+        const filePath = String(toolInput.filePath || toolInput.path || '');
+        if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
+            tags.push('typescript');
+        }
+        else if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+            tags.push('javascript');
+        }
+        else if (filePath.endsWith('.json')) {
+            tags.push('config');
+        }
+        else if (filePath.endsWith('.md')) {
+            tags.push('documentation');
+        }
+        else if (filePath.endsWith('.test.ts') || filePath.endsWith('.spec.ts')) {
+            tags.push('test');
+        }
+        // Feature/fix detection
+        if (contentLower.includes('fix') || contentLower.includes('bug')) {
+            tags.push('bugfix');
+        }
+        else if (contentLower.includes('refactor')) {
+            tags.push('refactor');
+        }
+        else if (contentLower.includes('feature') || contentLower.includes('add')) {
+            tags.push('feature');
+        }
+        else if (contentLower.includes('test')) {
+            tags.push('testing');
+        }
+    }
+    // Bash command tags
+    if (tool === 'bash') {
+        const cmd = String(toolInput.command || toolInput.cmd || '');
+        if (cmd.includes('git commit')) {
+            tags.push('commit', 'version-control');
+        }
+        else if (cmd.includes('test') || cmd.includes('jest') || cmd.includes('vitest')) {
+            tags.push('testing', 'test');
+        }
+        else if (cmd.includes('build') || cmd.includes('compile')) {
+            tags.push('build');
+        }
+        else if (cmd.includes('install')) {
+            tags.push('dependencies');
+        }
+        else if (cmd.includes('lint') || cmd.includes('format')) {
+            tags.push('linting');
+        }
+    }
+    // Task tags
+    if (tool === 'task' || tool === 'todowrite') {
+        tags.push('task', 'planning');
+        if (contentLower.includes('fix') || contentLower.includes('bug')) {
+            tags.push('bugfix');
+        }
+        else if (contentLower.includes('feature')) {
+            tags.push('feature');
+        }
+        else if (contentLower.includes('refactor')) {
+            tags.push('refactor');
+        }
+    }
+    // Deduplicate
+    return [...new Set(tags)];
+}
+/**
+ * Extract tags from commit message
+ */
+export function extractCommitTags(commitMessage) {
+    const tags = ['commit'];
+    const msg = commitMessage.toLowerCase();
+    // Conventional commits
+    if (msg.startsWith('feat:') || msg.includes('feature')) {
+        tags.push('feature', 'conventional-commit');
+    }
+    else if (msg.startsWith('fix:') || msg.includes('bugfix')) {
+        tags.push('bugfix', 'conventional-commit');
+    }
+    else if (msg.startsWith('refactor:')) {
+        tags.push('refactor', 'conventional-commit');
+    }
+    else if (msg.startsWith('docs:')) {
+        tags.push('documentation', 'conventional-commit');
+    }
+    else if (msg.startsWith('test:')) {
+        tags.push('testing', 'conventional-commit');
+    }
+    else if (msg.startsWith('chore:')) {
+        tags.push('chore', 'conventional-commit');
+    }
+    return tags;
+}
+/**
+ * Extract tags from file path
+ */
+export function extractFileTags(filePath) {
+    const tags = [];
+    const path = filePath.toLowerCase();
+    // By extension
+    if (path.endsWith('.ts') || path.endsWith('.tsx')) {
+        tags.push('typescript');
+    }
+    else if (path.endsWith('.js') || path.endsWith('.jsx')) {
+        tags.push('javascript');
+    }
+    else if (path.endsWith('.py')) {
+        tags.push('python');
+    }
+    else if (path.endsWith('.go')) {
+        tags.push('golang');
+    }
+    else if (path.endsWith('.rs')) {
+        tags.push('rust');
+    }
+    else if (path.endsWith('.java')) {
+        tags.push('java');
+    }
+    else if (path.endsWith('.json')) {
+        tags.push('config');
+    }
+    else if (path.endsWith('.md')) {
+        tags.push('documentation');
+    }
+    // By directory pattern
+    if (path.includes('/test') || path.includes('/tests') || path.includes('__tests__')) {
+        tags.push('test');
+    }
+    else if (path.includes('/src/')) {
+        tags.push('source');
+    }
+    else if (path.includes('/lib/') || path.includes('/utils/')) {
+        tags.push('library');
+    }
+    else if (path.includes('/config/') || path.includes('/scripts/')) {
+        tags.push('config');
+    }
+    return tags;
+}
+//# sourceMappingURL=auto-tagger.js.map

package/dist/core/hooks/capture-filter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Capture Filter - Smart filtering of tool usage
+ *
+ * Don't capture everything - filter out noise.
+ * Only capture meaningful actions that warrant memory.
+ */
+/** Tool categories for capture */
+export type ToolCategory = 'reading' | 'modification' | 'command' | 'commit' | 'testing' | 'search' | 'planning' | 'other';
+/** Capture decision */
+export interface CaptureDecision {
+    shouldCapture: boolean;
+    reason?: string;
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * Check if a tool should be captured
+ *
+ * Rules:
+ * - Write, Edit, MultiEdit → capture (modification)
+ * - Bash with commit → capture (commit)
+ * - Bash with test → capture (testing)
+ * - Task → capture (planning)
+ * - Read, Glob, grep → skip (reading - too noisy)
+ */
+export declare function shouldCaptureTool(toolName: string): boolean;
+/**
+ * Get detailed capture decision
+ */
+export declare function getCaptureDecision(toolName: string): CaptureDecision;
+/**
+ * Check if Bash command should be captured based on content
+ */
+export declare function shouldCaptureBashCommand(command: string): {
+    capture: boolean;
+    reason: string;
+};
+/**
+ * Categorize tool for tagging
+ */
+export declare function categorizeTool(toolName: string): ToolCategory;
+//# sourceMappingURL=capture-filter.d.ts.map

package/dist/core/hooks/capture-filter.js

@@ -0,0 +1,128 @@
+/**
+ * Capture Filter - Smart filtering of tool usage
+ *
+ * Don't capture everything - filter out noise.
+ * Only capture meaningful actions that warrant memory.
+ */
+/**
+ * Check if a tool should be captured
+ *
+ * Rules:
+ * - Write, Edit, MultiEdit → capture (modification)
+ * - Bash with commit → capture (commit)
+ * - Bash with test → capture (testing)
+ * - Task → capture (planning)
+ * - Read, Glob, grep → skip (reading - too noisy)
+ */
+export function shouldCaptureTool(toolName) {
+    const decision = getCaptureDecision(toolName);
+    return decision.shouldCapture;
+}
+/**
+ * Get detailed capture decision
+ */
+export function getCaptureDecision(toolName) {
+    const tool = toolName.toLowerCase();
+    // High priority - always capture
+    if (['write', 'edit', 'multiedit'].includes(tool)) {
+        return {
+            shouldCapture: true,
+            reason: 'File modification',
+            priority: 'high',
+        };
+    }
+    // Command with specific patterns
+    if (tool === 'bash') {
+        // Let the caller check the command for commit/test patterns
+        return {
+            shouldCapture: true, // Will be filtered by content check
+            reason: 'Command execution',
+            priority: 'medium',
+        };
+    }
+    // Task operations
+    if (['task', 'todowrite'].includes(tool)) {
+        return {
+            shouldCapture: true,
+            reason: 'Task/planning activity',
+            priority: 'high',
+        };
+    }
+    // Skip noisy tools
+    if (['read', 'glob', 'grep', 'websearch', 'webfetch', 'codesearch'].includes(tool)) {
+        return {
+            shouldCapture: false,
+            reason: 'Reading/search tool - too noisy',
+            priority: 'low',
+        };
+    }
+    // Skip other common noise
+    if (['bash'].includes(tool)) {
+        return {
+            shouldCapture: false, // Too noisy without filtering
+            reason: 'General command - filtered',
+            priority: 'low',
+        };
+    }
+    // Default: don't capture unknown tools
+    return {
+        shouldCapture: false,
+        reason: 'Unknown tool',
+        priority: 'low',
+    };
+}
+/**
+ * Check if Bash command should be captured based on content
+ */
+export function shouldCaptureBashCommand(command) {
+    const cmd = command.toLowerCase();
+    // Git commits - HIGH priority
+    if (cmd.includes('git commit') || cmd.includes('git add') && cmd.includes('git commit')) {
+        return { capture: true, reason: 'Git commit' };
+    }
+    // Tests - HIGH priority
+    if (cmd.includes('test') || cmd.includes('jest') || cmd.includes('vitest') ||
+        cmd.includes('pytest') || cmd.includes('bun test')) {
+        return { capture: true, reason: 'Test execution' };
+    }
+    // Build/compile - MEDIUM priority
+    if (cmd.includes('build') || cmd.includes('compile') || cmd.includes('tsc') ||
+        cmd.includes('bun build') || cmd.includes('npm run build')) {
+        return { capture: true, reason: 'Build/compile' };
+    }
+    // Installation - LOW priority
+    if (cmd.includes('npm install') || cmd.includes('bun install') ||
+        cmd.includes('pip install') || cmd.includes('yarn add')) {
+        return { capture: false, reason: 'Package installation - too noisy' };
+    }
+    // Git operations (non-commit) - LOW priority
+    if (cmd.includes('git') && !cmd.includes('commit')) {
+        return { capture: false, reason: 'Git operations - not commits' };
+    }
+    // File operations - MEDIUM priority
+    if (cmd.includes('mkdir') || cmd.includes('touch') || cmd.includes('rm ')) {
+        return { capture: true, reason: 'File operation' };
+    }
+    // Default - don't capture
+    return { capture: false, reason: 'General command' };
+}
+/**
+ * Categorize tool for tagging
+ */
+export function categorizeTool(toolName) {
+    const tool = toolName.toLowerCase();
+    if (['write', 'edit', 'multiedit'].includes(tool)) {
+        return 'modification';
+    }
+    if (tool === 'bash') {
+        return 'command';
+    }
+    if (['read', 'glob', 'grep', 'websearch', 'webfetch'].includes(tool)) {
+        return 'reading';
+    }
+    if (['task', 'todowrite', 'todo-read'].includes(tool)) {
+        return 'planning';
+    }
+    return 'other';
+}
+//# sourceMappingURL=capture-filter.js.map

package/dist/core/index.d.ts

@@ -1,10 +1,10 @@
-export * from './cache.js';
-export * from './context.js';
-export * from './database.js';
+export * from './storage/cache.js';
+export * from './context/context.js';
+export * from './storage/database.js';
 export * from './embeddings.js';
-export * from './observations.js';
-export * from './privacy.js';
+export * from './ingestion/learnings.js';
+export * from './security/privacy.js';
 export * from './projects.js';
-export * from './secret-detector.js';
+export * from './security/secret-detector.js';
 export * from './worker.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -1,14 +1,14 @@
 // Shared services - Core utilities and services
-export * from './cache.js';
-export * from './context.js';
-export * from './database.js';
+export * from './storage/cache.js';
+export * from './context/context.js';
+export * from './storage/database.js';
 export * from './embeddings.js';
 // Note: local-embeddings exports duplicate of embeddings, import directly when needed
 // export * from './local-embeddings.js';
-export * from './observations.js';
-export * from './privacy.js';
+export * from './ingestion/learnings.js';
+export * from './security/privacy.js';
 export * from './projects.js';
 // Note: redis exports duplicates of cache, import directly when needed
-export * from './secret-detector.js';
+export * from './security/secret-detector.js';
 export * from './worker.js';
 //# sourceMappingURL=index.js.map

package/dist/core/{agent-memory.js → ingestion/agent-memory.js}

@@ -4,11 +4,11 @@
  */
 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';
+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
  */
@@ -53,9 +53,7 @@ export async function storeAgentMemory(content, context, options = {}) {
         throw error;
     }
 }
-// ============================================================================
 // Helper Functions
-// ============================================================================
 function calculateReadScope(context, visibility) {
     switch (visibility) {
         case 'private':

package/dist/core/{core-memory.js → ingestion/core-memory.js}

@@ -5,10 +5,10 @@
  * 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 './database.js';
-import config from '../config.js';
+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;

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

@@ -0,0 +1,57 @@
+/**
+ * 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

@@ -0,0 +1,202 @@
+/**
+ * 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