@chude/memory 4.0.0

package/dist/infrastructure/database/connection.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Database Connection and Initialization
+ *
+ * Provides SQLite database initialization with WAL mode,
+ * performance pragmas, busy timeout, integrity checks, and FTS5 verification.
+ */
+import { Database } from "bun:sqlite";
+/**
+ * Database configuration options
+ */
+export interface DatabaseConfig {
+    /** Path to the database file. Use ":memory:" for in-memory database. */
+    path: string;
+    /** Whether to create the database if it doesn't exist. Default: true */
+    create?: boolean;
+    /** Whether to apply schema on initialization. Default: true */
+    applySchema?: boolean;
+    /** Whether to enable WAL mode. Default: true */
+    walMode?: boolean;
+    /** Cache size in KB (negative) or pages (positive). Default: -64000 (64MB) */
+    cacheSize?: number;
+    /** Busy timeout in milliseconds for handling database locks. Default: 5000 */
+    busyTimeout?: number;
+    /** Whether to run quick integrity check on startup. Default: true for file DB, false for :memory: */
+    quickCheck?: boolean;
+}
+/**
+ * Result of database initialization
+ */
+export interface DatabaseInitResult {
+    /** The initialized database instance */
+    db: Database;
+    /** Whether WAL mode was successfully enabled */
+    walEnabled: boolean;
+    /** Whether FTS5 extension is available */
+    fts5Available: boolean;
+    /** Whether sqlite-vec extension is loaded (vector search available) */
+    sqliteVecAvailable: boolean;
+}
+/**
+ * Attempt to load the sqlite-vec extension into a database.
+ *
+ * sqlite-vec enables vector similarity search via vec0 virtual tables.
+ * If the extension is not available (e.g., not installed), this returns false
+ * and the database continues to work with FTS5-only search.
+ *
+ * @param db - Database instance to load the extension into
+ * @returns true if loaded successfully, false otherwise
+ */
+export declare function loadSqliteVecExtension(db: Database): boolean;
+/**
+ * Get the default database path
+ *
+ * @returns Path to the database file
+ */
+export declare function getDefaultDbPath(): string;
+/**
+ * Initialize a SQLite database with optimal settings
+ *
+ * Configures:
+ * - Foreign keys enabled
+ * - WAL mode (for file-based databases)
+ * - Performance pragmas (synchronous, cache_size, temp_store)
+ * - FTS5 support verification
+ * - Schema creation (optional)
+ *
+ * @param config - Database configuration options
+ * @returns Database instance with initialization status
+ * @throws Error if FTS5 is not available
+ *
+ * @example
+ * ```typescript
+ * // In-memory database
+ * const { db } = initializeDatabase({ path: ":memory:" });
+ *
+ * // File-based database with custom cache
+ * const { db, walEnabled } = initializeDatabase({
+ *     path: "./data/memory.db",
+ *     cacheSize: -32000  // 32MB
+ * });
+ * ```
+ */
+export declare function initializeDatabase(config: DatabaseConfig): DatabaseInitResult;
+/**
+ * Close the database connection with proper cleanup
+ *
+ * Performs a WAL checkpoint before closing to ensure all changes are
+ * written to the main database file. Switches journal mode to DELETE
+ * to remove WAL/SHM files that would otherwise retain OS-level locks
+ * on Windows.
+ *
+ * initializeDatabase() re-enables WAL on the next open, so the
+ * journal mode switch has no functional impact on subsequent connections.
+ *
+ * Note: On Windows, Bun's SQLite binding may hold the .db file descriptor
+ * until garbage collection. Test code that needs to delete the database
+ * file immediately after close should use tests/helpers/test-database.ts
+ * which handles this with a conditional GC + retry strategy.
+ *
+ * @param db - Database instance to close
+ */
+export declare function closeDatabase(db: Database): void;
+/**
+ * Perform a passive WAL checkpoint
+ *
+ * Checkpoints as much of the WAL as possible without blocking.
+ * Use this for periodic checkpointing during long operations.
+ *
+ * @param db - Database instance to checkpoint
+ */
+export declare function checkpointDatabase(db: Database): void;
+/**
+ * Result of a WAL checkpoint operation
+ */
+export interface CheckpointResult {
+    /** Number of WAL frames that could not be checkpointed (busy) */
+    busy: number;
+    /** Total number of frames in the WAL file */
+    log: number;
+    /** Number of frames successfully checkpointed */
+    checkpointed: number;
+}
+/**
+ * Perform a truncating WAL checkpoint after bulk operations
+ *
+ * Uses TRUNCATE mode which:
+ * 1. Checkpoints all frames from WAL to main database
+ * 2. Truncates the WAL file to zero size
+ * 3. May block briefly if other connections are active
+ *
+ * Call this after bulk insert operations to:
+ * - Reduce WAL file size
+ * - Ensure all changes are in main database file
+ * - Optimize subsequent read performance
+ *
+ * @param db - Database instance to checkpoint
+ * @returns Checkpoint result with frame counts
+ */
+export declare function bulkOperationCheckpoint(db: Database): CheckpointResult;
+/**
+ * Initialize a database with error wrapping
+ *
+ * Wraps initializeDatabase and ensures all errors are MemoryError instances.
+ * Use this for CLI entry points where structured error handling is needed.
+ *
+ * @param config - Database configuration options
+ * @returns Database instance with initialization status
+ * @throws MemoryError for any initialization failure
+ *
+ * @example
+ * ```typescript
+ * try {
+ *     const { db } = initializeDatabaseSafe({ path: "./data/memory.db" });
+ * } catch (error) {
+ *     if (error instanceof MemoryError) {
+ *         console.error(`[${error.code}] ${error.message}`);
+ *     }
+ * }
+ * ```
+ */
+export declare function initializeDatabaseSafe(config: DatabaseConfig): DatabaseInitResult;

package/dist/infrastructure/database/event-log.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Event-Log SSOT Manager
+ *
+ * Manages the append-only JSONL event log as the source of truth (SSOT),
+ * and handles playing back events to rebuild database projections.
+ */
+import type { Database } from "bun:sqlite";
+import { Fact } from "../../domain/entities/fact.js";
+/**
+ * Append a serialized Fact entity into the plain-text event log.
+ */
+export declare function appendEvent(fact: Fact, logPath?: string): Promise<void>;
+/**
+ * Read all Fact events sequentially from the plain-text event log.
+ * Yields Fact entities.
+ */
+export declare function readEvents(logPath?: string, eventsDir?: string): AsyncGenerator<Fact, void, unknown>;
+/**
+ * Completely wipe the derived database projections and play back the entire
+ * plain-text events.jsonl timeline sequentially to rebuild the SQLite database.
+ */
+export declare function rebuildProjections(db: Database, logPath?: string, eventsDir?: string): Promise<void>;

package/dist/infrastructure/database/health-checker.d.ts

@@ -0,0 +1,248 @@
+/**
+ * Health Checker
+ *
+ * Provides database integrity checking and system health verification.
+ * Used by the doctor command for diagnostics.
+ *
+ * Features:
+ * - SQLite PRAGMA integrity_check and quick_check
+ * - Directory permission verification
+ * - Hook installation status
+ * - Configuration validation
+ */
+import { Database } from "bun:sqlite";
+import { type HookStatus } from "../hooks/index.js";
+/**
+ * Database health status
+ */
+export interface DatabaseHealth {
+    /** Database file exists */
+    exists: boolean;
+    /** Database file is readable */
+    readable: boolean;
+    /** Database file is writable */
+    writable: boolean;
+    /** Integrity check result */
+    integrity: "ok" | "corrupted" | "unknown";
+    /** Database file size in bytes */
+    size: number;
+}
+/**
+ * Directory permissions status
+ */
+export interface PermissionsHealth {
+    /** Config directory is accessible */
+    configDir: boolean;
+    /** Logs directory is accessible */
+    logsDir: boolean;
+    /** Claude source directory (~/.claude/projects) is accessible */
+    sourceDir: boolean;
+}
+/**
+ * Hook status
+ */
+export interface HooksHealth {
+    /** Hooks are installed in settings.json */
+    installed: boolean;
+    /** autoSync is enabled in config */
+    enabled: boolean;
+    /** Last hook run timestamp */
+    lastRun: Date | null;
+}
+/**
+ * Configuration validity status
+ */
+export interface ConfigHealth {
+    /** Configuration is valid */
+    valid: boolean;
+    /** Issues found during validation */
+    issues: string[];
+}
+/**
+ * Embedding health status
+ */
+export interface EmbeddingHealth {
+    /** Whether embedding config exists */
+    configured: boolean;
+    /** Provider identifier */
+    provider: string;
+    /** Model identifier */
+    model: string;
+    /** Embedding dimensions */
+    dimensions: number;
+    /** Whether embedding is enabled */
+    enabled: boolean;
+    /** Whether the provider is ready to generate embeddings */
+    ready: boolean;
+    /** Reason for readiness status (e.g., "API key not set") */
+    readyReason?: string | undefined;
+}
+/**
+ * sqlite-vec extension health status
+ */
+export interface SqliteVecHealth {
+    /** Whether sqlite-vec extension is loadable */
+    available: boolean;
+    /** sqlite-vec version string, or null if not available */
+    version: string | null;
+}
+/**
+ * Search capability status
+ */
+export interface SearchCapability {
+    /** FTS5 is available */
+    fts5: boolean;
+    /** sqlite-vec extension is loaded */
+    sqliteVec: boolean;
+    /** Number of messages with embeddings */
+    embeddedCount: number;
+    /** Total number of messages */
+    totalMessages: number;
+    /** Percentage of messages with embeddings */
+    coveragePercent: number;
+    /** Default search mode from config */
+    defaultMode: string;
+    /** Whether vector search is ready (extension + embeddings) */
+    vectorReady: boolean;
+}
+/**
+ * LLM Extraction health status
+ */
+export interface LlmExtractionHealth {
+    /** The active LLM provider */
+    provider: string;
+    /** The active LLM model */
+    model: string;
+    /** Whether extraction is configured and ready */
+    ready: boolean;
+    /** Reason for readiness status */
+    readyReason?: string | undefined;
+}
+/**
+ * Complete health check result
+ */
+export interface HealthCheckResult {
+    /** Database health status */
+    database: DatabaseHealth;
+    /** Directory permissions status */
+    permissions: PermissionsHealth;
+    /** Hook status */
+    hooks: HooksHealth;
+    /** Configuration validity status */
+    config: ConfigHealth;
+    /** Embedding configuration status */
+    embedding: EmbeddingHealth;
+    /** sqlite-vec extension availability */
+    sqliteVec: SqliteVecHealth;
+    /** Search capability status */
+    searchCapability: SearchCapability;
+    /** LLM extraction provider status */
+    llmExtraction: LlmExtractionHealth;
+}
+/**
+ * Test path overrides for testing
+ */
+export interface HealthCheckOverrides {
+    /** Override database path */
+    dbPath?: string | undefined;
+    /** Override config directory */
+    configDir?: string | undefined;
+    /** Override logs directory */
+    logsDir?: string | undefined;
+    /** Override source directory */
+    sourceDir?: string | undefined;
+    /** Override hook-related paths (settings.json, backup, hook script) */
+    hookOverrides?: import("../hooks/settings-manager.js").PathOverrides | undefined;
+    /** Optional pre-calculated hook status to avoid redundant file reads */
+    preCalculatedHookStatus?: HookStatus | undefined;
+}
+/**
+ * Check database integrity using PRAGMA integrity_check
+ *
+ * Full integrity check that verifies:
+ * - All pages are reachable
+ * - All index entries exist
+ * - All UNIQUE/NOT NULL constraints
+ *
+ * @param db Database instance
+ * @returns "ok" if integrity check passes, "corrupted" otherwise
+ */
+export declare function checkDatabaseIntegrity(db: Database): "ok" | "corrupted";
+/**
+ * Check database integrity using PRAGMA quick_check
+ *
+ * Faster check that skips some verifications:
+ * - Verifies structural integrity
+ * - Skips index consistency checks
+ * - Good for startup verification
+ *
+ * @param db Database instance
+ * @returns "ok" if quick check passes, "corrupted" otherwise
+ */
+export declare function checkQuickIntegrity(db: Database): "ok" | "corrupted";
+/**
+ * Check directory permissions
+ *
+ * @param path Directory path to check
+ * @returns Readable and writable status
+ */
+export declare function checkDirectoryPermissions(path: string): {
+    readable: boolean;
+    writable: boolean;
+};
+/**
+ * Check hook installation and configuration status
+ *
+ * @param logPath Optional explicit log file path (used by tests to point
+ *   at a fixture; production reads from the XDG-resolved path)
+ * @param configPath Optional explicit config file path (used by tests)
+ * @returns Hook status including installation, enabled state, and last run
+ */
+export declare function checkHookStatus(logPath?: string | undefined, configPath?: string | undefined, hookOverrides?: import("../hooks/settings-manager.js").PathOverrides | undefined, preCalculatedHookStatus?: HookStatus | undefined): HooksHealth;
+/**
+ * Validate configuration and collect issues
+ *
+ * @param configPath Optional explicit config file path (used by tests)
+ * @returns Validity status and list of issues
+ */
+export declare function checkConfigValidity(configPath?: string): ConfigHealth;
+/**
+ * Check sqlite-vec extension availability
+ *
+ * Attempts to load sqlite-vec in a temporary in-memory database
+ * and query its version. Closes the database before returning.
+ *
+ * @returns sqlite-vec availability and version
+ */
+export declare function checkSqliteVecAvailability(): SqliteVecHealth;
+/**
+ * Check embedding configuration status
+ *
+ * Loads config and returns the embedding section values.
+ *
+ * @param configPath Optional explicit config file path (used by tests)
+ * @returns Embedding health status
+ */
+export declare function checkEmbeddingConfig(configPath?: string): EmbeddingHealth;
+/**
+ * Check LLM Fact Extraction provider health status
+ *
+ * @param configPath Optional explicit config file path
+ * @returns LLM extraction health status
+ */
+export declare function checkLlmExtractionHealth(configPath?: string): LlmExtractionHealth;
+/**
+ * Run comprehensive health check
+ *
+ * Orchestrates all health checks:
+ * - Database existence, permissions, and integrity
+ * - Directory permissions (config, logs, source)
+ * - Hook installation and configuration
+ * - Configuration validity
+ * - Embedding configuration
+ * - sqlite-vec extension availability
+ *
+ * @param overrides Optional path overrides for testing
+ * @returns Complete health check result
+ */
+export declare function runHealthCheck(overrides?: HealthCheckOverrides): HealthCheckResult;

package/dist/infrastructure/database/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Database Infrastructure
+ *
+ * Provides SQLite database initialization, schema management,
+ * and connection utilities for memory.
+ */
+export { SCHEMA_SQL, createSchema, checkFts5Support, SESSIONS_TABLE, MESSAGES_META_TABLE, MESSAGES_FTS_TABLE, TOOL_USES_TABLE, LINKS_TABLE, TOPICS_TABLE, EXTRACTION_STATE_TABLE, EMBEDDING_STATE_TABLE, EMBEDDING_STATE_ADD_MODEL_NAME, MESSAGE_EMBEDDINGS_TABLE, FRICTION_LOG_TABLE, BACKFILL_STATE_TABLE, type SchemaOptions, } from "./schema.js";
+export { initializeDatabase, initializeDatabaseSafe, closeDatabase, checkpointDatabase, bulkOperationCheckpoint, getDefaultDbPath, type DatabaseConfig, type DatabaseInitResult, type CheckpointResult, } from "./connection.js";
+export { SqliteSessionRepository, SqliteMessageRepository, SqliteExtractionStateRepository, SqliteToolUseRepository, SqliteLinkRepository, type BatchResult, type BatchOptions, type RelatedLink, EmbeddingRepository, type UnembeddedMessage, type EmbeddingBatchItem, SqliteFrictionRepository, SqliteBackfillStateRepository, } from "./repositories/index.js";
+export { Fts5SearchService, HybridSearchService, type HybridSearchDeps, type SearchMeta, SqliteStatsService, SqliteContextService, SqliteProjectResolver, type ProjectContext, type ContextOptions, type ToolUsage, } from "./services/index.js";
+export { checkDatabaseIntegrity, checkQuickIntegrity, checkDirectoryPermissions, checkConfigValidity, checkHookStatus, checkSqliteVecAvailability, checkEmbeddingConfig, runHealthCheck, type DatabaseHealth, type PermissionsHealth, type HooksHealth, type ConfigHealth, type EmbeddingHealth, type SqliteVecHealth, type HealthCheckResult, type HealthCheckOverrides, type SearchCapability, } from "./health-checker.js";

package/dist/infrastructure/database/repositories/backfill-state-repository.d.ts

@@ -0,0 +1,19 @@
+/**
+ * SQLite implementation of IBackfillStateRepository.
+ *
+ * Persists backfill state records tracking which sessions have been
+ * backfilled (daily log generated). Uses INSERT OR REPLACE for upsert
+ * semantics on the session_id primary key.
+ */
+import type { Database } from "bun:sqlite";
+import { BackfillState } from "../../../domain/entities/backfill-state.js";
+import type { IBackfillStateRepository, BackfillStatusCounts } from "../../../domain/ports/repositories.js";
+export declare class SqliteBackfillStateRepository implements IBackfillStateRepository {
+    private readonly db;
+    constructor(db: Database);
+    findBySessionId(sessionId: string): Promise<BackfillState | null>;
+    findAll(): Promise<BackfillState[]>;
+    save(state: BackfillState): Promise<void>;
+    countByStatus(): Promise<BackfillStatusCounts>;
+    private toEntity;
+}

package/dist/infrastructure/database/repositories/embedding-repository.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Embedding Repository
+ *
+ * Data access layer for embedding storage. Manages the embedding_state
+ * and message_embeddings tables for incremental embedding and model
+ * change detection.
+ *
+ * The embedding_state table tracks which messages have been embedded
+ * and with which model (hash + human-readable name). The message_embeddings
+ * table is a vec0 virtual table storing the actual vector data.
+ */
+import type { Database } from "bun:sqlite";
+import type { IEmbeddingRepository, UnembeddedMessage, EmbeddingBatchItem } from "../../../domain/ports/repositories.js";
+export type { UnembeddedMessage, EmbeddingBatchItem };
+/**
+ * A vector KNN search result row.
+ */
+export interface VectorSearchRow {
+    /** The rowid of the matching message embedding */
+    rowid: number;
+    /** Cosine distance (0 = identical, 2 = opposite) */
+    distance: number;
+}
+/**
+ * Repository for embedding data access.
+ *
+ * Provides methods for querying unembedded messages, storing embedding
+ * results, tracking model hashes for change detection, and managing
+ * the embedding lifecycle (clear + re-embed).
+ */
+export declare class EmbeddingRepository implements IEmbeddingRepository {
+    private readonly db;
+    constructor(db: Database);
+    /**
+     * Find messages that have not yet been embedded.
+     *
+     * Uses LEFT JOIN on messages_meta and embedding_state to find
+     * messages without a corresponding embedding_state row.
+     *
+     * @param limit Maximum number of messages to return
+     * @returns Array of unembedded messages ordered by rowid ASC
+     */
+    findUnembedded(limit: number): UnembeddedMessage[];
+    /**
+     * Store a batch of embeddings in a single transaction.
+     *
+     * Inserts into both message_embeddings (vec0 virtual table) and
+     * embedding_state (tracking table) atomically. If any insert fails,
+     * the entire batch rolls back.
+     *
+     * @param items Array of embedding batch items (rowid + vector)
+     * @param modelHash Hash identifying the model configuration
+     * @param modelName Human-readable model name (e.g., "Xenova/all-MiniLM-L6-v2")
+     */
+    storeBatch(items: EmbeddingBatchItem[], modelHash: string, modelName: string): void;
+    /**
+     * Get the model hash currently stored in embedding_state.
+     *
+     * @returns The model hash string, or null if no embeddings exist
+     */
+    getStoredModelHash(): string | null;
+    /**
+     * Get the human-readable model name stored in embedding_state.
+     *
+     * Returns null if no embeddings exist or if model_name is empty
+     * (legacy data from before the model_name column was added).
+     *
+     * @returns The model name string, or null if unavailable
+     */
+    getStoredModelName(): string | null;
+    /**
+     * Delete all embeddings and embedding state.
+     *
+     * Used before re-embedding when the model has changed.
+     * Clears both message_embeddings (vec0) and embedding_state tables.
+     */
+    clearAllEmbeddings(): void;
+    /**
+     * Count the number of embedded messages.
+     *
+     * @returns The number of rows in embedding_state
+     */
+    getEmbeddedCount(): number;
+    /**
+     * Count the total number of messages in the database.
+     *
+     * @returns The number of rows in messages_meta
+     */
+    getTotalMessageCount(): number;
+    /**
+     * Search for nearest neighbors using sqlite-vec MATCH.
+     *
+     * Uses cosine distance via vec0 virtual table. Results are
+     * ordered by distance ASC (lower distance = more similar).
+     *
+     * @param queryEmbedding The query vector (Float32Array)
+     * @param limit Maximum number of results
+     * @returns Array of { rowid, distance } sorted by distance ASC
+     */
+    vectorKnnSearch(queryEmbedding: Float32Array, limit: number): VectorSearchRow[];
+    /**
+     * Get the dimension of currently stored embeddings.
+     *
+     * Queries a single embedding from message_embeddings and determines
+     * its dimension from the byte length (Float32 = 4 bytes per dimension).
+     *
+     * @returns The dimension count, or null if no embeddings are stored
+     */
+    getStoredEmbeddingDimensions(): number | null;
+    /**
+     * Drop and recreate the message_embeddings vec0 table with new dimensions.
+     *
+     * Used when the provider/model changes and the new model produces
+     * vectors of a different dimension than what is currently stored.
+     * Also clears embedding_state since the tracking data is logically
+     * paired with the vector data.
+     *
+     * @param dimensions The number of dimensions for the new vec0 table
+     */
+    recreateVecTable(dimensions: number): void;
+}

package/dist/infrastructure/database/repositories/entity-repository.d.ts

@@ -0,0 +1,73 @@
+/**
+ * SQLite Entity Repository Implementation
+ *
+ * Persists Entity domain objects to SQLite database.
+ * Implements IEntityRepository with deduplication using INSERT OR REPLACE.
+ */
+import type { Database } from "bun:sqlite";
+import type { IEntityRepository, EntityListOptions } from "../../../domain/ports/repositories.js";
+import { Entity, type ExtractedEntityType } from "../../../domain/entities/entity.js";
+/**
+ * SQLite implementation of IEntityRepository
+ *
+ * Features:
+ * - INSERT OR REPLACE for deduplication on (type, name)
+ * - Max confidence preservation on upsert
+ * - Case-insensitive name matching
+ * - Batch insert with transaction support
+ */
+export declare class SqliteEntityRepository implements IEntityRepository {
+    private readonly db;
+    private readonly findByIdStmt;
+    private readonly findByNameStmt;
+    private readonly findBySessionStmt;
+    private readonly insertStmt;
+    private readonly existsStmt;
+    private readonly updateConfidenceStmt;
+    private readonly linkSessionStmt;
+    private readonly linkEntityStmt;
+    constructor(db: Database);
+    /**
+     * Find an entity by its unique database identifier.
+     */
+    findById(id: number): Promise<Entity | null>;
+    /**
+     * Find an entity by type and name (unique constraint).
+     * Uses case-insensitive matching and trims whitespace from search name.
+     */
+    findByName(type: ExtractedEntityType, name: string): Promise<Entity | null>;
+    /**
+     * Find all entities linked to a specific session.
+     */
+    findBySession(sessionId: string): Promise<Entity[]>;
+    /**
+     * Find entities of a specific type with optional filtering.
+     * Builds dynamic query based on options.
+     */
+    findByType(type: ExtractedEntityType, options?: EntityListOptions): Promise<Entity[]>;
+    /**
+     * Save an entity to the repository.
+     * Uses INSERT OR REPLACE pattern with max confidence preservation.
+     * Returns entity with assigned id.
+     */
+    save(entity: Entity): Promise<Entity>;
+    /**
+     * Save multiple entities in a single transaction.
+     * Returns entities with assigned ids.
+     */
+    saveMany(entities: Entity[]): Promise<Entity[]>;
+    /**
+     * Create a link between an entity and a session.
+     * Increments frequency if link already exists.
+     */
+    linkToSession(entityId: number, sessionId: string, frequency?: number): Promise<void>;
+    /**
+     * Create a relationship link between two entities.
+     * Ignores duplicates (INSERT OR IGNORE).
+     */
+    linkEntities(sourceId: number, targetId: number, relationship: "related" | "implies" | "contradicts", weight?: number): Promise<void>;
+    /**
+     * Convert a database row to an Entity domain object.
+     */
+    private rowToEntity;
+}

package/dist/infrastructure/database/repositories/extraction-log-repository.d.ts

@@ -0,0 +1,17 @@
+/**
+ * SQLite implementation of IExtractionLogRepository.
+ *
+ * Persists fact extraction run statistics and metadata.
+ * Uses INSERT OR REPLACE for idempotency on session_id primary key.
+ */
+import type { Database } from "bun:sqlite";
+import type { IExtractionLogRepository, ExtractionLogEntry } from "../../../domain/ports/repositories.js";
+export declare class SqliteExtractionLogRepository implements IExtractionLogRepository {
+    private readonly db;
+    constructor(db: Database);
+    findById(sessionId: string): Promise<ExtractionLogEntry | null>;
+    save(entry: ExtractionLogEntry): Promise<void>;
+    findAll(): Promise<ExtractionLogEntry[]>;
+    clearAll(): Promise<void>;
+    private toEntry;
+}