/**
 * @agentkits/memory - Project-Scoped Memory System
 *
 * Provides persistent memory for Claude Code sessions within a project.
 * Stores data in .claude/memory/memory.db using SQLite with sqlite-vec
 * for vector indexing and semantic search.
 *
 * @module @agentkits/memory
 *
 * @example
 * ```typescript
 * import { ProjectMemoryService } from '@agentkits/memory';
 *
 * // Initialize memory for current project
 * const memory = new ProjectMemoryService('.claude/memory');
 * await memory.initialize();
 *
 * // Store an entry
 * await memory.store({
 *   key: 'auth-pattern',
 *   content: 'Use JWT with refresh tokens for authentication',
 *   namespace: 'patterns',
 *   tags: ['auth', 'security'],
 * });
 *
 * // Query entries
 * const patterns = await memory.query({
 *   type: 'hybrid',
 *   namespace: 'patterns',
 *   tags: ['auth'],
 *   limit: 10,
 * });
 *
 * // Semantic search (if embeddings enabled)
 * const similar = await memory.semanticSearch('how to authenticate users', 5);
 *
 * // Session management
 * await memory.startSession();
 * await memory.checkpoint('Completed authentication setup');
 * await memory.endSession('Successfully implemented auth');
 * ```
 */
import { EventEmitter } from 'node:events';
import { IMemoryBackend, MemoryEntry, MemoryEntryInput, MemoryEntryUpdate, MemoryQuery, SearchResult, SearchOptions, BackendStats, HealthCheckResult, EmbeddingGenerator, SessionInfo } from './types.js';
export * from './types.js';
export { CacheManager, TieredCacheManager } from './cache-manager.js';
export { LocalEmbeddingsService, createLocalEmbeddings, createEmbeddingGenerator, PersistentEmbeddingCache, createPersistentEmbeddingCache, } from './embeddings/index.js';
export { HybridSearchEngine, createHybridSearchEngine, TokenEconomicsTracker, createTokenEconomicsTracker, } from './search/index.js';
export { BetterSqlite3Backend, createBetterSqlite3Backend, createJapaneseOptimizedBackend, } from './better-sqlite3-backend.js';
/**
 * Create a better-sqlite3 backend with FTS5 trigram tokenizer and sqlite-vec
 */
export declare function createAutoBackend(databasePath: string, options?: {
    verbose?: boolean;
    dimensions?: number;
}): IMemoryBackend;
/**
 * Configuration for ProjectMemoryService
 */
export interface ProjectMemoryConfig {
    /** Base directory for memory storage (default: .claude/memory) */
    baseDir: string;
    /** Database filename (default: memory.db) */
    dbFilename: string;
    /**
     * @deprecated This option is kept for backwards compatibility but has no effect.
     * Vector search is now handled by sqlite-vec in the backend.
     */
    enableVectorIndex?: boolean;
    /** Vector dimensions for embeddings (default: 384 for local models) */
    dimensions: number;
    /** Embedding generator function (optional) */
    embeddingGenerator?: EmbeddingGenerator;
    /** Enable caching */
    cacheEnabled: boolean;
    /** Cache size (number of entries) */
    cacheSize: number;
    /** Cache TTL in milliseconds */
    cacheTtl: number;
    /** Auto-persist interval in milliseconds */
    autoPersistInterval: number;
    /** Maximum entries before cleanup */
    maxEntries: number;
    /** Enable verbose logging */
    verbose: boolean;
}
/**
 * Project-Scoped Memory Service
 *
 * High-level interface for project memory that provides:
 * - Persistent storage in .claude/memory/memory.db
 * - Session tracking and checkpoints
 * - Vector search with sqlite-vec (persisted, no rebuild needed)
 * - Migration from existing markdown files
 * - Backward-compatible markdown exports
 */
export declare class ProjectMemoryService extends EventEmitter implements IMemoryBackend {
    private config;
    private backend;
    private cache;
    private initialized;
    private currentSession;
    constructor(baseDirOrConfig?: string | Partial<ProjectMemoryConfig>);
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
    /**
     * Check if migration is needed (entries with embeddings not yet indexed in sqlite-vec)
     */
    needsMigration(): Promise<{
        needed: boolean;
        count: number;
    }>;
    /**
     * Migrate existing embeddings to sqlite-vec index.
     * Call this to index any entries that have embeddings but are not yet in the vector index.
     */
    migrateEmbeddingsToVec(): Promise<{
        migrated: number;
        skipped: number;
        errors: number;
    }>;
    store(entry: MemoryEntry): Promise<void>;
    get(id: string): Promise<MemoryEntry | null>;
    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
    delete(id: string): Promise<boolean>;
    query(query: MemoryQuery): Promise<MemoryEntry[]>;
    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
    bulkInsert(entries: MemoryEntry[]): Promise<void>;
    bulkDelete(ids: string[]): Promise<number>;
    count(namespace?: string): Promise<number>;
    listNamespaces(): Promise<string[]>;
    clearNamespace(namespace: string): Promise<number>;
    getStats(): Promise<BackendStats>;
    healthCheck(): Promise<HealthCheckResult>;
    /**
     * Store an entry from simple input
     */
    storeEntry(input: MemoryEntryInput): Promise<MemoryEntry>;
    /**
     * Semantic search by content string
     */
    semanticSearch(content: string, k?: number, threshold?: number): Promise<SearchResult[]>;
    /**
     * Get entries by namespace (convenience method)
     */
    getByNamespace(namespace: string, limit?: number): Promise<MemoryEntry[]>;
    /**
     * Get or create an entry
     */
    getOrCreate(namespace: string, key: string, creator: () => MemoryEntryInput | Promise<MemoryEntryInput>): Promise<MemoryEntry>;
    /**
     * Start a new session
     */
    startSession(): Promise<SessionInfo>;
    /**
     * Get current session
     */
    getCurrentSession(): SessionInfo | null;
    /**
     * Create a checkpoint in current session
     */
    checkpoint(description: string): Promise<void>;
    /**
     * End current session
     */
    endSession(summary?: string): Promise<SessionInfo | null>;
    /**
     * Get recent sessions
     */
    getRecentSessions(limit?: number): Promise<SessionInfo[]>;
    private ensureInitialized;
}
/**
 * Create a memory service for the current project
 */
export declare function createProjectMemory(baseDir?: string, options?: Partial<ProjectMemoryConfig>): ProjectMemoryService;
/**
 * Create a memory service with embedding support
 */
export declare function createEmbeddingMemory(baseDir: string, embeddingGenerator: EmbeddingGenerator, dimensions?: number): ProjectMemoryService;
export default ProjectMemoryService;
//# sourceMappingURL=index.d.ts.map