squish-memory 1.0.2 → 1.2.0

package/dist/core/adapters/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * UAM Adapter Types
+ *
+ * Universal Agent Memory - Adapter interfaces for different AI coding agents.
+ * Each agent (Claude Code, OpenCode, Cursor, Windsurf, etc.) has its own adapter
+ * that defines how to integrate with Squish.
+ *
+ * Key concepts:
+ * - Agent adapters use native config formats where possible
+ * - Hooks are explicit (calls squish_learn) not hidden
+ * - Uses existing MCP tools (squish_context, squish_learn)
+ */
+import { z } from 'zod';
+/** Agent types supported by UAM */
+export type AgentType = 'claude-code' | 'opencode' | 'cursor' | 'windsurf' | 'codex' | 'generic';
+/** Hook event types */
+export type HookEvent = 'onSessionStart' | 'onSessionEnd' | 'onToolCall' | 'onPreCompact' | 'onPostCompact';
+/** 3-Layer depth for progressive disclosure */
+export type TimelineDepth = 'index' | 'timeline' | 'detail';
+/** Memory context for session start */
+export interface SessionContextInput {
+    project: string;
+    mode: 'startup' | 'resume' | 'compact';
+    sessionId?: string;
+}
+export interface SessionContextOutput {
+    mode: string;
+    project: string;
+    memories: string;
+    count: number;
+    snapshot?: {
+        id: string;
+        content: string;
+    } | null;
+}
+/** Tool call observation */
+export interface ToolObservationInput {
+    toolName: string;
+    toolInput: Record<string, unknown>;
+    toolResult: unknown;
+    project: string;
+    sessionId?: string;
+}
+export interface ToolObservationOutput {
+    memoryId: string;
+    category: 'reading' | 'modification' | 'commit' | 'testing' | 'command' | 'search' | 'planning' | 'other';
+    content: string;
+}
+/** Agent configuration */
+export interface AgentConfig {
+    /** Unique agent identifier */
+    agentId: string;
+    /** Human-readable name */
+    name: string;
+    /** Agent type */
+    type: AgentType;
+    /** MCP server configuration */
+    mcp: {
+        command: string;
+        args: string[];
+        env?: Record<string, string>;
+    };
+    /** Hook patterns (native format for each agent) */
+    hooks?: {
+        sessionStart?: unknown;
+        sessionEnd?: unknown;
+        preCompact?: unknown;
+        postToolUse?: unknown;
+    };
+    /** Custom settings */
+    settings?: Record<string, unknown>;
+}
+/** Agent adapter interface */
+export interface AgentAdapter {
+    /** Unique adapter ID */
+    id: string;
+    /** Agent type */
+    type: AgentType;
+    /** Human-readable name */
+    name: string;
+    /** Agent version (if known) */
+    version?: string;
+    /** Get session context for injection */
+    getSessionContext(input: SessionContextInput): Promise<SessionContextOutput>;
+    /** Record a tool observation */
+    recordObservation(input: ToolObservationInput): Promise<ToolObservationOutput>;
+    /** Get timeline (3-layer progressive disclosure) */
+    getTimeline(query: string, depth: TimelineDepth, limit: number): Promise<unknown[]>;
+    /** Check if this agent should capture this tool */
+    shouldCaptureTool(toolName: string): boolean;
+    /** Get raw config for native integration */
+    getNativeConfig(): AgentConfig;
+}
+/** Registry for managing adapters */
+export interface AdapterRegistry {
+    /** Register a new adapter */
+    register(adapter: AgentAdapter): void;
+    /** Get adapter by type */
+    get(type: AgentType): AgentAdapter | undefined;
+    /** List all registered adapters */
+    list(): AgentAdapter[];
+    /** Load all adapters from config directory */
+    loadAll(configDir: string): Promise<void>;
+}
+/** Zod schemas for validation */
+export declare const SessionContextInputSchema: z.ZodObject<{
+    project: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        startup: "startup";
+        resume: "resume";
+        compact: "compact";
+    }>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ToolObservationInputSchema: z.ZodObject<{
+    toolName: z.ZodString;
+    toolInput: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    toolResult: z.ZodUnknown;
+    project: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TimelineInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    depth: z.ZodDefault<z.ZodEnum<{
+        index: "index";
+        timeline: "timeline";
+        detail: "detail";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/** Tool category mapping */
+export declare const TOOL_CATEGORIES: Record<string, ToolObservationOutput['category']>;
+/**
+ * Categorize a tool call
+ */
+export declare function categorizeTool(toolName: string): ToolObservationOutput['category'];
+//# sourceMappingURL=types.d.ts.map

package/dist/core/adapters/types.js

@@ -0,0 +1,50 @@
+/**
+ * UAM Adapter Types
+ *
+ * Universal Agent Memory - Adapter interfaces for different AI coding agents.
+ * Each agent (Claude Code, OpenCode, Cursor, Windsurf, etc.) has its own adapter
+ * that defines how to integrate with Squish.
+ *
+ * Key concepts:
+ * - Agent adapters use native config formats where possible
+ * - Hooks are explicit (calls squish_learn) not hidden
+ * - Uses existing MCP tools (squish_context, squish_learn)
+ */
+import { z } from 'zod';
+/** Zod schemas for validation */
+export const SessionContextInputSchema = z.object({
+    project: z.string(),
+    mode: z.enum(['startup', 'resume', 'compact']).default('startup'),
+    sessionId: z.string().optional(),
+});
+export const ToolObservationInputSchema = z.object({
+    toolName: z.string(),
+    toolInput: z.record(z.string(), z.unknown()),
+    toolResult: z.unknown(),
+    project: z.string(),
+    sessionId: z.string().optional(),
+});
+export const TimelineInputSchema = z.object({
+    query: z.string(),
+    depth: z.enum(['index', 'timeline', 'detail']).default('index'),
+    limit: z.number().min(1).max(100).default(10),
+});
+/** Tool category mapping */
+export const TOOL_CATEGORIES = {
+    'Read': 'reading',
+    'Write': 'modification',
+    'Edit': 'modification',
+    'Bash': 'command',
+    'grep': 'search',
+    'Glob': 'search',
+    'TodoWrite': 'planning',
+    'TodoRead': 'planning',
+    'Task': 'planning',
+};
+/**
+ * Categorize a tool call
+ */
+export function categorizeTool(toolName) {
+    return TOOL_CATEGORIES[toolName] || 'other';
+}
+//# sourceMappingURL=types.js.map

package/dist/core/agent-preferences.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Agent Preferences - Accumulate and retrieve agent preferences from learnings
+ * Enables agents to learn and evolve over time
+ */
+/**
+ * Update agent preference from a learning
+ */
+export declare function updateAgentPreference(projectId: string, content: string, sourceMemoryId?: string): Promise<void>;
+/**
+ * Get all agent preferences for a project
+ */
+export declare function getAgentPreferences(projectId: string): Promise<Array<{
+    key: string;
+    value: string;
+}>>;
+//# sourceMappingURL=agent-preferences.d.ts.map

package/dist/core/agent-preferences.js

@@ -0,0 +1,124 @@
+/**
+ * Agent Preferences - Accumulate and retrieve agent preferences from learnings
+ * Enables agents to learn and evolve over time
+ */
+import { getDb } from '../db/index.js';
+import { eq, and } from 'drizzle-orm';
+import { logger } from './logger.js';
+/**
+ * Extract preference from learning content
+ * E.g., "Prefer bun over npm" -> key: "prefer_bun", value: "bun"
+ */
+function extractPreference(content) {
+    const patterns = [
+        // "Prefer X over Y"
+        /prefer\s+(\w+)\s+over\s+(\w+)/i,
+        // "Always use X"
+        /always\s+use\s+(\w+)/i,
+        // "Use X instead of Y"
+        /use\s+(\w+)\s+instead\s+of\s+(\w+)/i,
+        // "X is better than Y"
+        /(\w+)\s+is\s+better\s+than\s+(\w+)/i,
+        // "Don't use X"
+        /(?:don't|do not|never)\s+use\s+(\w+)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = content.match(pattern);
+        if (match) {
+            const key = `prefer_${match[1].toLowerCase()}`;
+            const value = match[2]?.toLowerCase() || 'true';
+            return { key, value };
+        }
+    }
+    return null;
+}
+/**
+ * Update agent preference from a learning
+ */
+export async function updateAgentPreference(projectId, content, sourceMemoryId) {
+    const preference = extractPreference(content);
+    if (!preference)
+        return;
+    try {
+        const db = getDb();
+        // Check if preference exists
+        const existing = await db.query.agentPreferences?.findFirst(and(eq(db.schema.agentPreferences.projectId, projectId), eq(db.schema.agentPreferences.key, preference.key))).catch(() => null);
+        if (existing) {
+            // Update existing preference
+            await db.update(db.schema.agentPreferences)
+                .set({
+                value: preference.value,
+                sourceMemoryId: sourceMemoryId,
+                usageCount: (existing.usageCount ?? 0) + 1,
+                lastUpdated: Math.floor(Date.now() / 1000)
+            })
+                .where(eq(db.schema.agentPreferences.id, existing.id))
+                .catch(() => {
+                // Fallback for SQLite which uses different table name
+                const sqlite = db._?.sqlite || db;
+                if (sqlite) {
+                    sqlite.prepare(`
+              UPDATE agent_preferences 
+              SET value = ?, source_memory_id = ?, usage_count = usage_count + 1, last_updated = ?
+              WHERE project_id = ? AND key = ?
+            `).run(preference.value, sourceMemoryId, Math.floor(Date.now() / 1000), projectId, preference.key);
+                }
+            });
+            logger.info(`[AgentPrefs] Updated preference: ${preference.key} = ${preference.value}`);
+        }
+        else {
+            // Insert new preference
+            const id = `pref_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            await db.insert(db.schema.agentPreferences)
+                .values({
+                id,
+                projectId,
+                key: preference.key,
+                value: preference.value,
+                sourceMemoryId: sourceMemoryId ?? null,
+                confidence: 0.5,
+                usageCount: 1
+            })
+                .catch(() => {
+                // Fallback for SQLite
+                const sqlite = db._?.sqlite || db;
+                if (sqlite) {
+                    sqlite.prepare(`
+              INSERT INTO agent_preferences (id, project_id, key, value, source_memory_id, confidence, usage_count)
+              VALUES (?, ?, ?, ?, ?, 0.5, 1)
+            `).run(id, projectId, preference.key, preference.value, sourceMemoryId ?? null);
+                }
+            });
+            logger.info(`[AgentPrefs] Created preference: ${preference.key} = ${preference.value}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`[AgentPrefs] Failed to update preference:`, error);
+    }
+}
+/**
+ * Get all agent preferences for a project
+ */
+export async function getAgentPreferences(projectId) {
+    try {
+        const db = getDb();
+        const results = await db.query.agentPreferences?.findMany({
+            where: eq(db.schema.agentPreferences.projectId, projectId)
+        }).catch(() => []);
+        if (results && results.length > 0) {
+            return results.map(p => ({ key: p.key, value: p.value }));
+        }
+        // Fallback for SQLite
+        const sqlite = db._?.sqlite || db;
+        if (sqlite) {
+            const rows = sqlite.prepare('SELECT key, value FROM agent_preferences WHERE project_id = ?').all(projectId);
+            return rows.map(r => ({ key: r.key, value: r.value }));
+        }
+        return [];
+    }
+    catch (error) {
+        logger.warn(`[AgentPrefs] Failed to get preferences:`, error);
+        return [];
+    }
+}
+//# sourceMappingURL=agent-preferences.js.map

package/dist/{algorithms → core/algorithms}/analytics/token-estimator.d.ts

@@ -2,7 +2,7 @@
  * Token estimation for calculating context window savings from merges.
  * Uses simple heuristic: 1 token ≈ 4 characters (can be upgraded to tiktoken for accuracy).
  */
-import type { Memory } from '../../drizzle/schema.js';
+import type { Memory } from '../../../db/drizzle/schema.js';
 import type { MergedMemory } from '../strategies/merge-strategies.js';
 export declare function estimateTokensSaved(sources: Memory[], merged: MergedMemory): number;
 export declare function calculateProjectTokenSavings(projectId: string): Promise<{

package/dist/{algorithms → core/algorithms}/analytics/token-estimator.js

@@ -2,9 +2,9 @@
  * Token estimation for calculating context window savings from merges.
  * Uses simple heuristic: 1 token ≈ 4 characters (can be upgraded to tiktoken for accuracy).
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 function estimateTokensSimple(text) {
     if (!text)

package/dist/{algorithms → core/algorithms}/detection/semantic-ranker.d.ts

@@ -2,7 +2,7 @@
  * Semantic ranking using embeddings (Stage 2 of two-stage detection).
  * Ranks candidates from Stage 1 by semantic similarity using cosine distance.
  */
-import type { Memory } from '../../drizzle/schema.js';
+import type { Memory } from '../../../db/drizzle/schema.js';
 export interface RankedCandidate {
     memoryId1: string;
     memoryId2: string;

package/dist/{algorithms → core/algorithms}/detection/semantic-ranker.js

@@ -2,7 +2,7 @@
  * Semantic ranking using embeddings (Stage 2 of two-stage detection).
  * Ranks candidates from Stage 1 by semantic similarity using cosine distance.
  */
-import { cosineSimilarity } from '../../core/local-embeddings.js';
+import { cosineSimilarity } from '../../../core/utils/vector-operations.js';
 function calculateConfidence(memory1, memory2, cosineSim) {
     if (cosineSim >= 0.90) {
         const factors = calculateConfidenceFactors(memory1, memory2);

package/dist/{algorithms → core/algorithms}/detection/two-stage-detector.d.ts

@@ -4,7 +4,7 @@
  * Stage 1: Hash-based prefiltering (SimHash + MinHash)
  * Stage 2: Semantic ranking using embeddings
  */
-import type { Memory, MemoryType } from '../../drizzle/schema.js';
+import type { Memory, MemoryType } from '../../../db/drizzle/schema.js';
 import { analyzePair } from './semantic-ranker.js';
 export interface MemoryPair {
     memory1: Memory;

package/dist/{algorithms → core/algorithms}/detection/two-stage-detector.js

@@ -4,18 +4,15 @@
  * Stage 1: Hash-based prefiltering (SimHash + MinHash)
  * Stage 2: Semantic ranking using embeddings
  */
-import { getEmbedding, getBatchEmbeddings } from '../../core/embeddings.js';
+import { getEmbedding, getBatchEmbeddings } from '../../../core/embeddings.js';
 import { SimHashFilter, MinHashFilter, findCandidatePairs } from './hash-filters.js';
 import { rankCandidates, analyzePair } from './semantic-ranker.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
 import { eq, and } from 'drizzle-orm';
 import * as crypto from 'crypto';
+import { getDbClient } from '../../../core/lib/db-client.js';
 export async function detectDuplicates(options) {
     const startTime = Date.now();
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     let query = db.select().from(schema.memories);
     if (options.projectId) {
         query = query.where(eq(schema.memories.projectId, options.projectId));
@@ -239,8 +236,7 @@ export async function detectDuplicates(options) {
     };
 }
 export async function analyzeMergePair(memoryId1, memoryId2) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const [memory1] = await db
         .select()
         .from(schema.memories)
@@ -271,6 +267,8 @@ function countByType(memories) {
         decision: 0,
         context: 0,
         preference: 0,
+        reflection: 0,
+        note: 0,
     };
     for (const memory of memories) {
         const type = memory.type;
@@ -281,8 +279,7 @@ function countByType(memories) {
     return counts;
 }
 export async function getDetectionStats(projectId) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
+    const { db, schema } = await getDbClient();
     const memories = await db
         .select()
         .from(schema.memories)

package/dist/{algorithms → core/algorithms}/handlers/approve-merge.js

@@ -2,13 +2,13 @@
  * Executes the approved merge in a single atomic transaction.
  */
 import { randomUUID } from 'crypto';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq, inArray } from 'drizzle-orm';
 import { mergeMemories } from '../strategies/merge-strategies.js';
 import { estimateTokensSaved } from '../analytics/token-estimator.js';
-import { getEmbedding } from '../../core/embeddings.js';
+import { getEmbedding } from '../../../core/embeddings.js';
 export async function handleApproveMerge(input) {
     try {
         const { proposalId, reviewNotes } = input;

package/dist/{algorithms → core/algorithms}/handlers/detect-duplicates.js

@@ -9,9 +9,9 @@ import { detectDuplicates } from '../detection/two-stage-detector.js';
 import { runSafetyChecks } from '../safety/safety-checks.js';
 import { mergeMemories } from '../strategies/merge-strategies.js';
 import { estimateTokensSaved } from '../analytics/token-estimator.js';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { buildSuccessResponse, buildErrorResponse } from '../utils/response-builder.js';
 /**
  * Handle detect_duplicate_memories tool call

package/dist/{algorithms → core/algorithms}/handlers/get-stats.js

@@ -3,9 +3,9 @@
  *
  * Returns statistics about memory merges for a project
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 import { calculateProjectTokenSavings, formatTokenCount } from '../analytics/token-estimator.js';
 /**

package/dist/{algorithms → core/algorithms}/handlers/list-proposals.js

@@ -3,9 +3,9 @@
  *
  * Lists pending merge proposals for user review
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq, desc } from 'drizzle-orm';
 /**
  * Handle list_merge_proposals tool call

package/dist/{algorithms → core/algorithms}/handlers/preview-merge.js

@@ -1,9 +1,9 @@
 /**
  * Shows a preview of the merged result without executing the merge.
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 import { estimateMergeSavingsPreview } from '../analytics/token-estimator.js';
 import { mergeMemories } from '../strategies/merge-strategies.js';

package/dist/{algorithms → core/algorithms}/handlers/reject-merge.js

@@ -3,9 +3,9 @@
  *
  * Rejects a merge proposal without executing it
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 /**
  * Handle reject_merge tool call

package/dist/{algorithms → core/algorithms}/handlers/reverse-merge.js

@@ -1,9 +1,9 @@
 /**
  * Reverses/undoes a completed merge and restores original memories.
  */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { getDb } from '../../../db/index.js';
+import { getSchema } from '../../../db/schema.js';
+import { createDatabaseClient } from '../../../core/storage/database.js';
 import { eq } from 'drizzle-orm';
 export async function handleReverseMerge(input) {
     try {

package/dist/core/algorithms/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Memory Merging Feature - Barrel Exports
+ *
+ * Provides a clean public API for memory merging functionality
+ */
+export * from './types.js';
+export { detectDuplicates, analyzeMergePair, getDetectionStats } from './detection/two-stage-detector.js';
+export { SimHashFilter, MinHashFilter, findCandidatePairs } from './detection/hash-filters.js';
+export { rankCandidates, analyzePair } from './detection/semantic-ranker.js';
+export { getMergeStrategy, mergeMemories, MERGE_STRATEGIES } from './strategies/merge-strategies.js';
+export type { MergeStrategy, MergedMemory } from './strategies/merge-strategies.js';
+export { runSafetyChecks, checkBlockers, formatSafetyResults, describeSafetyChecks } from './safety/safety-checks.js';
+export { estimateTokensSaved, calculateProjectTokenSavings, estimateMergeSavingsPreview, getTokenStatistics, formatTokenCount, formatSavingsReport, } from './analytics/token-estimator.js';
+export { handleDetectDuplicates } from './handlers/detect-duplicates.js';
+export { handleListProposals } from './handlers/list-proposals.js';
+export { handlePreviewMerge } from './handlers/preview-merge.js';
+export { handleApproveMerge } from './handlers/approve-merge.js';
+export { handleRejectMerge } from './handlers/reject-merge.js';
+export { handleReverseMerge } from './handlers/reverse-merge.js';
+export { handleGetMergeStats } from './handlers/get-stats.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/algorithms/index.js

@@ -0,0 +1,26 @@
+/**
+ * Memory Merging Feature - Barrel Exports
+ *
+ * Provides a clean public API for memory merging functionality
+ */
+// Types
+export * from './types.js';
+// Detection
+export { detectDuplicates, analyzeMergePair, getDetectionStats } from './detection/two-stage-detector.js';
+export { SimHashFilter, MinHashFilter, findCandidatePairs } from './detection/hash-filters.js';
+export { rankCandidates, analyzePair } from './detection/semantic-ranker.js';
+// Merge Strategies
+export { getMergeStrategy, mergeMemories, MERGE_STRATEGIES } from './strategies/merge-strategies.js';
+// Safety
+export { runSafetyChecks, checkBlockers, formatSafetyResults, describeSafetyChecks } from './safety/safety-checks.js';
+// Analytics & Tokens
+export { estimateTokensSaved, calculateProjectTokenSavings, estimateMergeSavingsPreview, getTokenStatistics, formatTokenCount, formatSavingsReport, } from './analytics/token-estimator.js';
+// Handlers (MCP Tools)
+export { handleDetectDuplicates } from './handlers/detect-duplicates.js';
+export { handleListProposals } from './handlers/list-proposals.js';
+export { handlePreviewMerge } from './handlers/preview-merge.js';
+export { handleApproveMerge } from './handlers/approve-merge.js';
+export { handleRejectMerge } from './handlers/reject-merge.js';
+export { handleReverseMerge } from './handlers/reverse-merge.js';
+export { handleGetMergeStats } from './handlers/get-stats.js';
+//# sourceMappingURL=index.js.map

package/dist/core/algorithms/operations/cache-maintenance.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hash cache maintenance - SimHash/MinHash signatures for duplicate detection
+ */
+export declare function updateCache(memoryId: string): Promise<boolean>;
+export declare function rebuildCache(projectId: string): Promise<{
+    processed: number;
+    succeeded: number;
+    failed: number;
+}>;
+export declare function isStale(memoryId: string): Promise<boolean>;
+export declare function cleanupOrphaned(projectId: string): Promise<number>;
+//# sourceMappingURL=cache-maintenance.d.ts.map