@chude/memory 4.0.0

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

@@ -0,0 +1,52 @@
+/**
+ * SQLite Extraction State Repository
+ *
+ * Implements IExtractionStateRepository using bun:sqlite prepared statements.
+ * Uses INSERT OR REPLACE for upsert semantics on state updates.
+ */
+import type { Database } from "bun:sqlite";
+import type { IExtractionStateRepository } from "../../../domain/ports/repositories.js";
+import { ExtractionState } from "../../../domain/entities/extraction-state.js";
+/**
+ * SQLite implementation of IExtractionStateRepository
+ *
+ * Uses prepared statements for all operations. State identity is based
+ * on the unique ID. INSERT OR REPLACE provides upsert semantics.
+ *
+ * Transaction-based state updates: save() should be called within the same
+ * transaction as message inserts. State is ONLY marked 'complete' after
+ * data commit succeeds.
+ */
+export declare class SqliteExtractionStateRepository implements IExtractionStateRepository {
+    private readonly findByIdStmt;
+    private readonly findBySessionPathStmt;
+    private readonly findPendingStmt;
+    private readonly saveStmt;
+    constructor(db: Database);
+    /**
+     * Map a database row to an ExtractionState entity
+     */
+    private rowToExtractionState;
+    /**
+     * Find an extraction state by its unique identifier.
+     */
+    findById(id: string): Promise<ExtractionState | null>;
+    /**
+     * Find extraction state by session path.
+     * Used to check if a session has already been extracted.
+     */
+    findBySessionPath(sessionPath: string): Promise<ExtractionState | null>;
+    /**
+     * Find all extractions that are pending or in progress.
+     * Used to resume interrupted extractions.
+     */
+    findPending(): Promise<ExtractionState[]>;
+    /**
+     * Save an extraction state to the repository.
+     * Uses INSERT OR REPLACE for upsert semantics.
+     *
+     * File metadata (fileMtime, fileSize) is stored for incremental sync detection.
+     * fileMtime is stored as ISO 8601 string, fileSize as integer bytes.
+     */
+    save(state: ExtractionState): Promise<void>;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * SQLite implementation of IFactRepository.
+ *
+ * Persists and queries derived Fact projections stored in SQLite.
+ * Follows hexagonal rules and maps row results to Fact domain entities.
+ */
+import type { Database } from "bun:sqlite";
+import { Fact } from "../../../domain/entities/fact.js";
+import type { IFactRepository } from "../../../domain/ports/repositories.js";
+export declare class SqliteFactRepository implements IFactRepository {
+    private readonly db;
+    constructor(db: Database);
+    findById(id: number): Promise<Fact | null>;
+    findByUuid(uuid: string): Promise<Fact | null>;
+    findByProject(project: string): Promise<Fact[]>;
+    findRecent(limit: number): Promise<Fact[]>;
+    save(fact: Fact): Promise<Fact>;
+    saveMany(facts: Fact[]): Promise<Fact[]>;
+    search(query: string, limit?: number): Promise<Fact[]>;
+    superseded(uuid: string, supersededAt: Date, supersededByUuid: string): Promise<void>;
+    supersede(uuid: string, supersededAt: Date, supersededByUuid: string): Promise<void>;
+    findAll(): Promise<Fact[]>;
+    clearAll(): Promise<void>;
+    private toEntity;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * SQLite Friction Repository
+ *
+ * Implements IFrictionRepository using bun:sqlite prepared statements.
+ * Provides full CRUD, stats aggregation via SQL, and weekly trend analysis.
+ */
+import type { Database } from "bun:sqlite";
+import type { IFrictionRepository, FrictionStats, FrictionPattern } from "../../../domain/ports/repositories.js";
+import { FrictionEntry, type FrictionCategory, type FrictionStatus } from "../../../domain/entities/friction-entry.js";
+/**
+ * SQLite implementation of IFrictionRepository.
+ *
+ * Persists FrictionEntry entities in the friction_log table with
+ * SQL-based aggregation for stats and trend analysis.
+ */
+export declare class SqliteFrictionRepository implements IFrictionRepository {
+    private readonly db;
+    constructor(db: Database);
+    save(entry: FrictionEntry): Promise<FrictionEntry>;
+    findById(id: number): Promise<FrictionEntry | null>;
+    findOpen(): Promise<FrictionEntry[]>;
+    findAll(options?: {
+        status?: FrictionStatus;
+        category?: FrictionCategory;
+        tool?: string;
+        sourceProject?: string;
+        limit?: number;
+    }): Promise<FrictionEntry[]>;
+    resolve(id: number, resolution: string): Promise<void>;
+    updateStatus(id: number, status: FrictionStatus): Promise<void>;
+    getStats(): Promise<FrictionStats>;
+    getWeeklyTrends(weeks: number): Promise<Array<{
+        week: string;
+        newCount: number;
+        resolvedCount: number;
+    }>>;
+    markReviewed(tool: string, reviewedAt: Date): Promise<void>;
+    findPatterns(threshold: number): Promise<FrictionPattern[]>;
+    deleteByPattern(pattern: string): Promise<number>;
+    private toEntity;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Repository Infrastructure
+ *
+ * Exports SQLite implementations of domain repository interfaces.
+ */
+export { SqliteSessionRepository } from "./session-repository.js";
+export { SqliteMessageRepository } from "./message-repository.js";
+export { SqliteExtractionStateRepository } from "./extraction-state-repository.js";
+export { SqliteToolUseRepository, type BatchResult, type BatchOptions, } from "./tool-use-repository.js";
+export { SqliteLinkRepository, type RelatedLink, } from "./link-repository.js";
+export { SqliteEntityRepository } from "./entity-repository.js";
+export { EmbeddingRepository, type UnembeddedMessage, type EmbeddingBatchItem, } from "./embedding-repository.js";
+export { SqliteMemoryFileRepository } from "./memory-file-repository.js";
+export { SqliteFrictionRepository } from "./friction-repository.js";
+export { SqliteBackfillStateRepository } from "./backfill-state-repository.js";
+export { SqliteFactRepository } from "./fact-repository.js";
+export { SqliteExtractionLogRepository } from "./extraction-log-repository.js";

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

@@ -0,0 +1,64 @@
+/**
+ * SQLite Link Repository
+ *
+ * Implements ILinkRepository using bun:sqlite prepared statements.
+ * Supports graph-like traversal using WITH RECURSIVE CTE.
+ */
+import type { Database } from "bun:sqlite";
+import type { ILinkRepository } from "../../../domain/ports/repositories.js";
+import { Link, type EntityType } from "../../../domain/entities/link.js";
+/**
+ * Link with hop count for graph traversal results
+ */
+export interface RelatedLink {
+    link: Link;
+    hop: number;
+}
+/**
+ * SQLite implementation of ILinkRepository
+ *
+ * Uses prepared statements for all operations. Supports multi-hop graph
+ * traversal using WITH RECURSIVE CTE with cycle prevention.
+ */
+export declare class SqliteLinkRepository implements ILinkRepository {
+    private readonly db;
+    private readonly findBySourceStmt;
+    private readonly findByTargetStmt;
+    private readonly insertStmt;
+    constructor(db: Database);
+    /**
+     * Map a database row to a Link entity
+     */
+    private rowToLink;
+    /**
+     * Find all links originating from a specific entity.
+     */
+    findBySource(sourceType: EntityType, sourceId: string): Promise<Link[]>;
+    /**
+     * Find all links pointing to a specific entity.
+     */
+    findByTarget(targetType: EntityType, targetId: string): Promise<Link[]>;
+    /**
+     * Find all entities related to a given entity within N hops.
+     * Uses WITH RECURSIVE CTE for graph traversal with cycle prevention.
+     *
+     * Note: The interface returns Link[], but we also track hop count.
+     * Use findRelatedWithHops() if hop information is needed.
+     */
+    findRelated(entityType: EntityType, entityId: string, maxHops?: number): Promise<Link[]>;
+    /**
+     * Find related entities with hop information.
+     * Enables weight decay analysis and distance-based filtering.
+     */
+    findRelatedWithHops(entityType: EntityType, entityId: string, maxHops?: number): Promise<RelatedLink[]>;
+    /**
+     * Save a link to the repository.
+     * Uses INSERT OR REPLACE for upsert behavior on unique constraint.
+     */
+    save(link: Link): Promise<void>;
+    /**
+     * Save multiple links in a single transaction.
+     * Uses BEGIN IMMEDIATE for write locking.
+     */
+    saveMany(links: Link[]): Promise<void>;
+}

package/dist/infrastructure/database/repositories/memory-file-repository.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SQLite Memory File Repository
+ *
+ * Implements IMemoryFileRepository using bun:sqlite prepared statements.
+ * Uses INSERT ... ON CONFLICT for idempotent upsert by file_path.
+ * FTS5 search delegates to sanitizeFtsQuery for safe query handling.
+ */
+import type { Database } from "bun:sqlite";
+import type { IMemoryFileRepository } from "../../../domain/ports/repositories.js";
+import { MemoryFile, type MemoryFileType } from "../../../domain/entities/memory-file.js";
+/**
+ * SQLite implementation of IMemoryFileRepository.
+ *
+ * Persists MemoryFile entities in the memory_files table with
+ * FTS5 search support via the memory_files_fts virtual table.
+ */
+export declare class SqliteMemoryFileRepository implements IMemoryFileRepository {
+    private readonly db;
+    constructor(db: Database);
+    findByPath(filePath: string): Promise<MemoryFile | null>;
+    findByType(fileType: MemoryFileType): Promise<MemoryFile[]>;
+    findByProject(projectEncoded: string): Promise<MemoryFile[]>;
+    save(file: MemoryFile): Promise<void>;
+    saveMany(files: MemoryFile[]): Promise<void>;
+    searchContent(query: string, limit?: number): Promise<MemoryFile[]>;
+    findCrossProjectLearnings(excludeProject?: string, limit?: number): Promise<MemoryFile[]>;
+    private toEntity;
+}

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

@@ -0,0 +1,87 @@
+/**
+ * SQLite Message Repository Implementation
+ *
+ * Implements IMessageRepository for SQLite with FTS5 integration.
+ * Messages are automatically indexed via triggers when inserted.
+ */
+import type { Database } from "bun:sqlite";
+import { Message } from "../../../domain/entities/message.js";
+import type { IMessageRepository } from "../../../domain/ports/repositories.js";
+/**
+ * Result of a batch save operation
+ */
+export interface BatchResult {
+    /** Number of messages successfully inserted */
+    inserted: number;
+    /** Number of messages skipped (duplicates or errors) */
+    skipped: number;
+    /** Details of any errors encountered */
+    errors: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * Options for batch save operations
+ */
+export interface BatchOptions {
+    /** Callback for progress updates */
+    onProgress?: (progress: {
+        inserted: number;
+        total: number;
+    }) => void;
+}
+/**
+ * SQLite implementation of IMessageRepository
+ *
+ * Features:
+ * - Prepared statements for optimal performance
+ * - INSERT OR IGNORE for idempotent inserts
+ * - Batch processing with transactions
+ * - FTS5 indexing via automatic triggers
+ */
+export declare class SqliteMessageRepository implements IMessageRepository {
+    private readonly db;
+    private readonly findByIdStmt;
+    private readonly findBySessionStmt;
+    private readonly existsStmt;
+    private readonly insertStmt;
+    /**
+     * Create a new SqliteMessageRepository
+     *
+     * @param db - Initialized SQLite database with schema applied
+     */
+    constructor(db: Database);
+    /**
+     * Find a message by its unique identifier
+     */
+    findById(id: string): Promise<Message | null>;
+    /**
+     * Find all messages belonging to a session, ordered by timestamp
+     */
+    findBySession(sessionId: string): Promise<Message[]>;
+    /**
+     * Save a message associated with a session
+     *
+     * Uses INSERT OR IGNORE for idempotent behavior - duplicates are silently skipped.
+     */
+    save(message: Message, sessionId: string): Promise<void>;
+    /**
+     * Save multiple messages in a single batch operation
+     *
+     * Processes messages in batches of 100 within immediate transactions.
+     * Reports progress via optional callback.
+     *
+     * @param messages - Array of message/sessionId pairs to save
+     * @param options - Optional configuration including progress callback
+     * @returns Result with counts of inserted, skipped, and any errors
+     */
+    saveMany(messages: Array<{
+        message: Message;
+        sessionId: string;
+    }>, options?: BatchOptions): Promise<BatchResult>;
+    /**
+     * Convert a database row to a Message entity
+     */
+    private rowToMessage;
+}

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

@@ -0,0 +1,125 @@
+/**
+ * SQLite Session Repository
+ *
+ * Implements ISessionRepository using bun:sqlite prepared statements.
+ * Uses INSERT OR IGNORE for idempotent session inserts.
+ */
+import type { Database } from "bun:sqlite";
+import type { ISessionRepository, SessionListOptions } from "../../../domain/ports/repositories.js";
+import { Session } from "../../../domain/entities/session.js";
+import { ProjectPath } from "../../../domain/value-objects/project-path.js";
+/**
+ * SQLite implementation of ISessionRepository
+ *
+ * Uses prepared statements for all operations. Session identity is based
+ * on the unique ID. INSERT OR IGNORE ensures idempotent saves.
+ */
+export declare class SqliteSessionRepository implements ISessionRepository {
+    private readonly db;
+    private readonly findByIdStmt;
+    private readonly findByProjectStmt;
+    private readonly findRecentStmt;
+    private readonly insertStmt;
+    private readonly deleteStmt;
+    private readonly updateSummaryStmt;
+    private readonly updateProjectNameStmt;
+    private readonly findDistinctEncodedPathsStmt;
+    constructor(db: Database);
+    /**
+     * Map a database row to a Session entity
+     *
+     * Uses project_path_decoded (lossless) not project_path_encoded (lossy
+     * for paths containing hyphens). The encoded form is only used for
+     * efficient lookups.
+     *
+     * Populates messageCount from the stored count in the database row,
+     * enabling accurate display without loading all messages.
+     */
+    private rowToSession;
+    /**
+     * Find a session by its unique identifier.
+     */
+    findById(id: string): Promise<Session | null>;
+    /**
+     * Find all sessions belonging to a project.
+     */
+    findByProject(projectPath: ProjectPath): Promise<Session[]>;
+    /**
+     * Find the most recent sessions across all projects.
+     */
+    findRecent(limit: number): Promise<Session[]>;
+    /**
+     * Save a session to the repository.
+     * Uses INSERT OR IGNORE for idempotency (no error on duplicate).
+     */
+    save(session: Session): Promise<void>;
+    /**
+     * Save multiple sessions in a single transaction.
+     * Uses BEGIN IMMEDIATE for write locking.
+     */
+    saveMany(sessions: Session[]): Promise<void>;
+    /**
+     * Delete a session by its identifier.
+     * Associated messages are deleted via foreign key CASCADE.
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Update the summary for a session.
+     *
+     * This triggers the sessions_fts_update trigger which indexes the summary
+     * in the FTS5 virtual table for full-text search.
+     *
+     * @param sessionId - Session identifier
+     * @param summary - LLM-generated summary text
+     */
+    updateSummary(sessionId: string, summary: string): Promise<void>;
+    /**
+     * Find sessions older than a specified date.
+     * Returns sessions where updated_at < cutoffDate.
+     *
+     * @param cutoffDate - Sessions updated before this date will be returned
+     * @returns Array of sessions older than the cutoff
+     */
+    findOlderThan(cutoffDate: Date): Promise<Session[]>;
+    /**
+     * Count sessions older than a specified date.
+     * Efficient for showing preview before purge.
+     *
+     * @param cutoffDate - Sessions updated before this date will be counted
+     * @returns Number of sessions older than the cutoff
+     */
+    countOlderThan(cutoffDate: Date): Promise<number>;
+    /**
+     * Delete sessions older than a specified date.
+     * Cascade deletes to messages, tool_uses, links, entities via foreign keys.
+     *
+     * @param cutoffDate - Sessions updated before this date will be deleted
+     * @returns Number of sessions deleted
+     */
+    deleteOlderThan(cutoffDate: Date): Promise<number>;
+    /**
+     * Update the project name for all sessions with a matching encoded path.
+     */
+    updateProjectName(encodedPath: string, projectName: string): Promise<number>;
+    /**
+     * Find all distinct encoded project paths stored in sessions.
+     */
+    findDistinctEncodedPaths(): Promise<string[]>;
+    /**
+     * Find sessions with filtering options.
+     * Builds dynamic WHERE clause based on provided filters.
+     */
+    findFiltered(options: SessionListOptions): Promise<Session[]>;
+    /**
+     * Search session summaries via FTS5.
+     *
+     * Queries the sessions_fts virtual table for summaries matching the
+     * given search term. Applies sanitizeFtsQuery() to prevent FTS5
+     * syntax errors from special characters in user input.
+     *
+     * @param query - Search query (sanitized internally for FTS5 safety)
+     * @param limit - Maximum results (default: 20)
+     * @returns Array of sessions whose summaries match the query
+     */
+    searchSummaries(query: string, limit?: number): Promise<Session[]>;
+}

package/dist/infrastructure/database/repositories/tool-use-repository.d.ts

@@ -0,0 +1,72 @@
+/**
+ * SQLite Tool Use Repository Implementation
+ *
+ * Persists ToolUse entities to SQLite database.
+ * Implements IToolUseRepository with batch support and idempotent inserts.
+ */
+import type { Database } from "bun:sqlite";
+import type { IToolUseRepository } from "../../../domain/ports/repositories.js";
+import { ToolUse } from "../../../domain/entities/tool-use.js";
+/**
+ * Result of a batch save operation
+ */
+export interface BatchResult {
+    inserted: number;
+    skipped: number;
+    errors: Array<{
+        id: string;
+        reason: string;
+    }>;
+}
+/**
+ * Options for batch save operations
+ */
+export interface BatchOptions {
+    onProgress?: (progress: {
+        inserted: number;
+        total: number;
+    }) => void;
+}
+/**
+ * SQLite implementation of IToolUseRepository
+ *
+ * Features:
+ * - INSERT OR IGNORE for idempotent inserts
+ * - JSON serialization for input objects
+ * - Batch insert with transaction support
+ * - Progress callback for CLI integration
+ */
+export declare class SqliteToolUseRepository implements IToolUseRepository {
+    private readonly db;
+    private readonly findByIdStmt;
+    private readonly findBySessionStmt;
+    private readonly insertStmt;
+    constructor(db: Database);
+    /**
+     * Find a tool use by its unique identifier.
+     */
+    findById(id: string): Promise<ToolUse | null>;
+    /**
+     * Find all tool uses belonging to a session.
+     * Returns array ordered by timestamp ascending.
+     */
+    findBySession(sessionId: string): Promise<ToolUse[]>;
+    /**
+     * Save a tool use associated with a session.
+     * Uses INSERT OR IGNORE for idempotent inserts.
+     */
+    save(toolUse: ToolUse, sessionId: string): Promise<void>;
+    /**
+     * Save multiple tool uses in a single transaction.
+     * Processes in batches of 100 for memory efficiency.
+     * Returns batch result with counts and any errors encountered.
+     */
+    saveMany(toolUses: Array<{
+        toolUse: ToolUse;
+        sessionId: string;
+    }>, options?: BatchOptions): Promise<BatchResult>;
+    /**
+     * Convert a database row to a ToolUse entity.
+     */
+    private rowToEntity;
+}