@snoai/memory 0.0.0-stage → 1.0.1

package/dist/connection-3IVXpuPE.d.ts

@@ -0,0 +1,391 @@
+import { o as SqliteRuntimeHandle, r as SqliteDatabaseLike } from "./sqlite-runtime-L_ywirTm.js";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { SQLiteColumn, SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
+declare namespace schema_d_exports {
+  export { memoryEvents, memoryTelemetryIncidents, memoryTelemetrySyncState, memoryUsageOutbox, nodixAtomicExtractionLedger, nodixMemories, nodixMemoryEntities, nodixMemoryExtractionTimestamps, nodixMemoryRelations, nodixMemorySuppressions, nodixProfileRecoveryEntries, nodixProviderAgentMappings, nodixProviderProjectAgents, nodixProviderProjectMappings, nodixTodoMigrationReceipts, nodixTodos, nodixUnplacedMemoryCandidates };
+}
+type TextColumn<Name extends string, Table extends string, NotNull extends boolean, HasDefault extends boolean, PrimaryKey extends boolean> = SQLiteColumn<{
+  name: Name;
+  tableName: Table;
+  dataType: "string";
+  columnType: "SQLiteText";
+  data: string;
+  driverParam: string;
+  notNull: NotNull;
+  hasDefault: HasDefault;
+  isPrimaryKey: PrimaryKey;
+  isAutoincrement: false;
+  hasRuntimeDefault: false;
+  enumValues: [string, ...string[]];
+  baseColumn: never;
+  identity: undefined;
+  generated: undefined;
+}, object, {
+  length: number | undefined;
+}>;
+type IntegerColumn<Name extends string, Table extends string, NotNull extends boolean, HasDefault extends boolean, PrimaryKey extends boolean> = SQLiteColumn<{
+  name: Name;
+  tableName: Table;
+  dataType: "number";
+  columnType: "SQLiteInteger";
+  data: number;
+  driverParam: number;
+  notNull: NotNull;
+  hasDefault: HasDefault;
+  isPrimaryKey: PrimaryKey;
+  isAutoincrement: false;
+  hasRuntimeDefault: false;
+  enumValues: undefined;
+  baseColumn: never;
+  identity: undefined;
+  generated: undefined;
+}>;
+type RealColumn<Name extends string, Table extends string, NotNull extends boolean, HasDefault extends boolean, PrimaryKey extends boolean> = SQLiteColumn<{
+  name: Name;
+  tableName: Table;
+  dataType: "number";
+  columnType: "SQLiteReal";
+  data: number;
+  driverParam: number;
+  notNull: NotNull;
+  hasDefault: HasDefault;
+  isPrimaryKey: PrimaryKey;
+  isAutoincrement: false;
+  hasRuntimeDefault: false;
+  enumValues: undefined;
+  baseColumn: never;
+  identity: undefined;
+  generated: undefined;
+}>;
+declare const nodixMemories: SQLiteTableWithColumns<{
+  name: "nodix_memories";
+  schema: undefined;
+  columns: {
+    id: TextColumn<"id", "nodix_memories", true, false, true>;
+    text: TextColumn<"text", "nodix_memories", true, false, false>;
+    category: TextColumn<"category", "nodix_memories", true, false, false>;
+    projectId: TextColumn<"project_id", "nodix_memories", true, false, false>;
+    importance: RealColumn<"importance", "nodix_memories", true, true, false>;
+    timestamp: IntegerColumn<"timestamp", "nodix_memories", true, false, false>;
+    timezone: TextColumn<"timezone", "nodix_memories", true, false, false>;
+    metadata: TextColumn<"metadata", "nodix_memories", false, true, false>;
+    contentHash: TextColumn<"content_hash", "nodix_memories", true, false, false>;
+    factId: TextColumn<"fact_id", "nodix_memories", false, false, false>;
+    derivedFrom: TextColumn<"derived_from", "nodix_memories", false, false, false>;
+    consolidationEpochId: TextColumn<"consolidation_epoch_id", "nodix_memories", false, false, false>;
+    confidenceSource: TextColumn<"confidence_source", "nodix_memories", false, false, false>;
+    lane: TextColumn<"lane", "nodix_memories", true, true, false>;
+    rawCandidateJson: TextColumn<"raw_candidate_json", "nodix_memories", false, false, false>;
+    dispositionReason: TextColumn<"disposition_reason", "nodix_memories", false, false, false>;
+    dispositionedAtMs: IntegerColumn<"dispositioned_at_ms", "nodix_memories", false, false, false>;
+    subject: TextColumn<"subject", "nodix_memories", false, false, false>;
+    attribute: TextColumn<"attribute", "nodix_memories", false, false, false>;
+    validFrom: IntegerColumn<"valid_from", "nodix_memories", false, false, false>;
+    validUntil: IntegerColumn<"valid_until", "nodix_memories", false, false, false>;
+    maturity: TextColumn<"maturity", "nodix_memories", false, false, false>;
+    source: TextColumn<"source", "nodix_memories", false, false, false>;
+    extractorVersion: TextColumn<"extractor_version", "nodix_memories", false, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixMemoryExtractionTimestamps: SQLiteTableWithColumns<{
+  name: "nodix_memory_extraction_timestamps";
+  schema: undefined;
+  columns: {
+    projectId: TextColumn<"project_id", "nodix_memory_extraction_timestamps", true, false, false>;
+    replayKey: TextColumn<"replay_key", "nodix_memory_extraction_timestamps", true, false, false>;
+    resolvedAtMs: IntegerColumn<"resolved_at_ms", "nodix_memory_extraction_timestamps", true, false, false>;
+    timeSource: TextColumn<"time_source", "nodix_memory_extraction_timestamps", false, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixMemoryRelations: SQLiteTableWithColumns<{
+  name: "nodix_memory_relations";
+  schema: undefined;
+  columns: {
+    sourceCardId: TextColumn<"source_card_id", "nodix_memory_relations", true, false, false>;
+    subject: TextColumn<"subject", "nodix_memory_relations", true, false, false>;
+    predicate: TextColumn<"predicate", "nodix_memory_relations", true, false, false>;
+    object: TextColumn<"object", "nodix_memory_relations", true, false, false>;
+    createdAt: IntegerColumn<"created_at", "nodix_memory_relations", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixMemorySuppressions: SQLiteTableWithColumns<{
+  name: "nodix_memory_suppressions";
+  schema: undefined;
+  columns: {
+    projectId: TextColumn<"project_id", "nodix_memory_suppressions", true, false, false>;
+    subject: TextColumn<"subject", "nodix_memory_suppressions", false, false, false>;
+    attribute: TextColumn<"attribute", "nodix_memory_suppressions", false, false, false>;
+    contentHash: TextColumn<"content_hash", "nodix_memory_suppressions", false, false, false>;
+    createdAt: IntegerColumn<"created_at", "nodix_memory_suppressions", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixTodos: SQLiteTableWithColumns<{
+  name: "nodix_todos";
+  schema: undefined;
+  columns: {
+    projectId: TextColumn<"project_id", "nodix_todos", true, false, false>;
+    activeTaskId: TextColumn<"active_task_id", "nodix_todos", true, false, false>;
+    description: TextColumn<"description", "nodix_todos", true, false, false>;
+    status: TextColumn<"status", "nodix_todos", true, false, false>;
+    openedAt: IntegerColumn<"opened_at", "nodix_todos", true, false, false>;
+    transitionedAt: IntegerColumn<"transitioned_at", "nodix_todos", true, false, false>;
+    closedAt: IntegerColumn<"closed_at", "nodix_todos", false, false, false>;
+    closeReason: TextColumn<"close_reason", "nodix_todos", false, false, false>;
+    sourceSession: TextColumn<"source_session", "nodix_todos", true, false, false>;
+    extractionPath: TextColumn<"extraction_path", "nodix_todos", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixTodoMigrationReceipts: SQLiteTableWithColumns<{
+  name: "nodix_todo_migration_receipts";
+  schema: undefined;
+  columns: {
+    migrationId: TextColumn<"migration_id", "nodix_todo_migration_receipts", true, false, true>;
+    beforeCount: IntegerColumn<"before_count", "nodix_todo_migration_receipts", true, false, false>;
+    afterCount: IntegerColumn<"after_count", "nodix_todo_migration_receipts", true, false, false>;
+    migratedAt: IntegerColumn<"migrated_at", "nodix_todo_migration_receipts", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixMemoryEntities: SQLiteTableWithColumns<{
+  name: "nodix_memory_entities";
+  schema: undefined;
+  columns: {
+    projectId: TextColumn<"project_id", "nodix_memory_entities", true, false, false>;
+    entityId: TextColumn<"entity_id", "nodix_memory_entities", true, false, false>;
+    displayName: TextColumn<"display_name", "nodix_memory_entities", true, false, false>;
+    normalizedName: TextColumn<"normalized_name", "nodix_memory_entities", true, false, false>;
+    createdAt: IntegerColumn<"created_at", "nodix_memory_entities", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixAtomicExtractionLedger: SQLiteTableWithColumns<{
+  name: "nodix_atomic_extraction_ledger";
+  schema: undefined;
+  columns: {
+    conversationId: TextColumn<"conversation_id", "nodix_atomic_extraction_ledger", true, false, false>;
+    chunkHash: TextColumn<"chunk_hash", "nodix_atomic_extraction_ledger", true, false, false>;
+    pipelineVersion: TextColumn<"pipeline_version", "nodix_atomic_extraction_ledger", true, false, false>;
+    state: TextColumn<"state", "nodix_atomic_extraction_ledger", true, false, false>;
+    rawChunk: TextColumn<"raw_chunk", "nodix_atomic_extraction_ledger", true, false, false>;
+    routingSnapshotId: TextColumn<"routing_snapshot_id", "nodix_atomic_extraction_ledger", true, false, false>;
+    runParametersJson: TextColumn<"run_parameters_json", "nodix_atomic_extraction_ledger", true, false, false>;
+    reprocessReason: TextColumn<"reprocess_reason", "nodix_atomic_extraction_ledger", false, false, false>;
+    reprocessAttemptCount: IntegerColumn<"reprocess_attempt_count", "nodix_atomic_extraction_ledger", true, true, false>;
+    failedReply: TextColumn<"failed_reply", "nodix_atomic_extraction_ledger", false, false, false>;
+    createdAt: IntegerColumn<"created_at", "nodix_atomic_extraction_ledger", true, false, false>;
+    updatedAt: IntegerColumn<"updated_at", "nodix_atomic_extraction_ledger", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixProviderProjectMappings: SQLiteTableWithColumns<{
+  name: "nodix_provider_project_mappings";
+  schema: undefined;
+  columns: {
+    userId: TextColumn<"user_id", "nodix_provider_project_mappings", true, false, false>;
+    externalSystem: TextColumn<"external_system", "nodix_provider_project_mappings", true, false, false>;
+    externalProjectKey: TextColumn<"external_project_key", "nodix_provider_project_mappings", true, false, false>;
+    projectId: TextColumn<"project_id", "nodix_provider_project_mappings", true, false, false>;
+    createdAtMs: IntegerColumn<"created_at_ms", "nodix_provider_project_mappings", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixProviderAgentMappings: SQLiteTableWithColumns<{
+  name: "nodix_provider_agent_mappings";
+  schema: undefined;
+  columns: {
+    userId: TextColumn<"user_id", "nodix_provider_agent_mappings", true, false, false>;
+    externalSystem: TextColumn<"external_system", "nodix_provider_agent_mappings", true, false, false>;
+    externalAgentKey: TextColumn<"external_agent_key", "nodix_provider_agent_mappings", true, false, false>;
+    agentId: TextColumn<"agent_id", "nodix_provider_agent_mappings", true, false, false>;
+    createdAtMs: IntegerColumn<"created_at_ms", "nodix_provider_agent_mappings", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixProviderProjectAgents: SQLiteTableWithColumns<{
+  name: "nodix_provider_project_agents";
+  schema: undefined;
+  columns: {
+    userId: TextColumn<"user_id", "nodix_provider_project_agents", true, false, false>;
+    projectId: TextColumn<"project_id", "nodix_provider_project_agents", true, false, false>;
+    agentId: TextColumn<"agent_id", "nodix_provider_project_agents", true, false, false>;
+    createdAtMs: IntegerColumn<"created_at_ms", "nodix_provider_project_agents", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const memoryEvents: SQLiteTableWithColumns<{
+  name: "nodix_memory_events";
+  schema: undefined;
+  columns: {
+    id: IntegerColumn<"id", "nodix_memory_events", true, true, true>;
+    eventType: TextColumn<"event_type", "nodix_memory_events", true, false, false>;
+    factId: TextColumn<"fact_id", "nodix_memory_events", false, false, false>;
+    memoryKind: TextColumn<"memory_kind", "nodix_memory_events", false, false, false>;
+    timestampMs: IntegerColumn<"timestamp_ms", "nodix_memory_events", true, false, false>;
+    sessionUuid: TextColumn<"session_uuid", "nodix_memory_events", false, false, false>;
+    turnId: TextColumn<"turn_id", "nodix_memory_events", false, false, false>;
+    agentId: TextColumn<"agent_id", "nodix_memory_events", true, false, false>;
+    projectId: TextColumn<"project_id", "nodix_memory_events", false, false, false>;
+    tenantId: TextColumn<"tenant_id", "nodix_memory_events", false, false, false>;
+    sourceEventId: IntegerColumn<"source_event_id", "nodix_memory_events", false, false, false>;
+    derivedFrom: TextColumn<"derived_from", "nodix_memory_events", false, false, false>;
+    consolidationEpochId: TextColumn<"consolidation_epoch_id", "nodix_memory_events", false, false, false>;
+    contentHash: TextColumn<"content_hash", "nodix_memory_events", false, false, false>;
+    receiptHmac: TextColumn<"receipt_hmac", "nodix_memory_events", false, false, false>;
+    keyVersion: IntegerColumn<"key_version", "nodix_memory_events", false, false, false>;
+    retrievalRank: IntegerColumn<"retrieval_rank", "nodix_memory_events", false, false, false>;
+    retrievalScore: RealColumn<"retrieval_score", "nodix_memory_events", false, false, false>;
+    queryTenantId: TextColumn<"query_tenant_id", "nodix_memory_events", false, false, false>;
+    resultTenantId: TextColumn<"result_tenant_id", "nodix_memory_events", false, false, false>;
+    metadataJson: TextColumn<"metadata_json", "nodix_memory_events", false, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const memoryUsageOutbox: SQLiteTableWithColumns<{
+  name: "nodix_memory_usage_outbox";
+  schema: undefined;
+  columns: {
+    id: IntegerColumn<"id", "nodix_memory_usage_outbox", true, true, true>;
+    eventType: TextColumn<"event_type", "nodix_memory_usage_outbox", true, false, false>;
+    payloadJson: TextColumn<"payload_json", "nodix_memory_usage_outbox", true, false, false>;
+    acceptedAtMs: IntegerColumn<"accepted_at_ms", "nodix_memory_usage_outbox", true, false, false>;
+    status: TextColumn<"status", "nodix_memory_usage_outbox", true, false, false>;
+    attemptCount: IntegerColumn<"attempt_count", "nodix_memory_usage_outbox", true, true, false>;
+    lastError: TextColumn<"last_error", "nodix_memory_usage_outbox", false, false, false>;
+    nextAttemptMs: IntegerColumn<"next_attempt_ms", "nodix_memory_usage_outbox", false, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const memoryTelemetryIncidents: SQLiteTableWithColumns<{
+  name: "nodix_memory_telemetry_incidents";
+  schema: undefined;
+  columns: {
+    id: IntegerColumn<"id", "nodix_memory_telemetry_incidents", true, true, true>;
+    incidentType: TextColumn<"incident_type", "nodix_memory_telemetry_incidents", true, false, false>;
+    severity: TextColumn<"severity", "nodix_memory_telemetry_incidents", true, false, false>;
+    message: TextColumn<"message", "nodix_memory_telemetry_incidents", true, false, false>;
+    payloadJson: TextColumn<"payload_json", "nodix_memory_telemetry_incidents", false, false, false>;
+    createdAtMs: IntegerColumn<"created_at_ms", "nodix_memory_telemetry_incidents", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const memoryTelemetrySyncState: SQLiteTableWithColumns<{
+  name: "nodix_memory_telemetry_sync_state";
+  schema: undefined;
+  columns: {
+    sink: TextColumn<"sink", "nodix_memory_telemetry_sync_state", true, false, true>;
+    lastEventId: IntegerColumn<"last_event_id", "nodix_memory_telemetry_sync_state", true, true, false>;
+    updatedAtMs: IntegerColumn<"updated_at_ms", "nodix_memory_telemetry_sync_state", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+/**
+ * Write attempts the extraction path could not place. A rejected candidate is
+ * preserved here with the raw model output that produced it, so a failed write
+ * costs retrievability and never the content. Rows here are NOT memories: no
+ * retrieval path reads this table.
+ */
+declare const nodixUnplacedMemoryCandidates: SQLiteTableWithColumns<{
+  name: "nodix_unplaced_memory_candidates";
+  schema: undefined;
+  columns: {
+    id: TextColumn<"id", "nodix_unplaced_memory_candidates", true, false, true>;
+    projectId: TextColumn<"project_id", "nodix_unplaced_memory_candidates", true, false, false>;
+    category: TextColumn<"category", "nodix_unplaced_memory_candidates", true, false, false>;
+    text: TextColumn<"text", "nodix_unplaced_memory_candidates", true, false, false>;
+    rawCandidateJson: TextColumn<"raw_candidate_json", "nodix_unplaced_memory_candidates", true, false, false>;
+    dispositionReason: TextColumn<"disposition_reason", "nodix_unplaced_memory_candidates", true, false, false>;
+    dispositionedAtMs: IntegerColumn<"dispositioned_at_ms", "nodix_unplaced_memory_candidates", true, false, false>;
+    sessionKey: TextColumn<"session_key", "nodix_unplaced_memory_candidates", false, false, false>;
+    dedupeHash: TextColumn<"dedupe_hash", "nodix_unplaced_memory_candidates", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+declare const nodixProfileRecoveryEntries: SQLiteTableWithColumns<{
+  name: "nodix_profile_recovery_entries";
+  schema: undefined;
+  columns: {
+    entryId: TextColumn<"entry_id", "nodix_profile_recovery_entries", true, false, true>;
+    mutationAttemptId: TextColumn<"mutation_attempt_id", "nodix_profile_recovery_entries", true, false, false>;
+    removedRowId: TextColumn<"removed_row_id", "nodix_profile_recovery_entries", true, false, false>;
+    projectId: TextColumn<"project_id", "nodix_profile_recovery_entries", true, false, false>;
+    profileFactId: TextColumn<"profile_fact_id", "nodix_profile_recovery_entries", true, false, false>;
+    sectionName: TextColumn<"section_name", "nodix_profile_recovery_entries", true, false, false>;
+    removedValue: TextColumn<"removed_value", "nodix_profile_recovery_entries", true, false, false>;
+    removedAtMs: IntegerColumn<"removed_at_ms", "nodix_profile_recovery_entries", true, false, false>;
+  };
+  dialect: "sqlite";
+}>;
+//#endregion
+//#region src/store/path-validation.d.ts
+/**
+ * Validate and prepare the storage directory for the SQLite database file.
+ * Resolves symlinks, creates missing directories, and checks write permissions.
+ * Returns the resolved parent directory path on success, or throws a descriptive error.
+ */
+declare function validateStoragePath(dbPath: string): string;
+//#endregion
+//#region src/store/connection.d.ts
+type RuntimeDrizzleDB = ReturnType<typeof drizzle<typeof schema_d_exports>>;
+type DrizzleDB = RuntimeDrizzleDB & {
+  $client: SqliteDatabaseLike;
+  vectorDimension: number;
+  vectorSearchAvailable: boolean;
+  retrySetup(): void;
+  /**
+   * The chokepoint wrapper over the same connection. Store code MUST use this
+   * (prepared-statement cache lives here); `$client` is the raw
+   * driver handle drizzle was constructed over and bypasses both.
+   */
+  chokepoint: SqliteDatabaseLike;
+};
+/**
+ * Opens the Node SQLite runtime and applies SQLite connection setup fallback behavior for missing data.
+ */
+/**
+ * Reads the locked embedding dimension from the existing `nodix_memory_chunk_vectors`
+ * DDL. Returns `undefined` if the DB file does not exist or the table has not
+ * been created yet; throws on a corrupt-state DDL.
+ *
+ * This lets out-of-band tooling (CLI preset switching, diagnostics) detect
+ * dim mismatches *before* the gateway boots, without paying the cost of
+ * spinning up a real `MemoryStore`. Keeping the regex here means CLI,
+ * diagnostics, and store startup agree on one canonical parser.
+ */
+declare function readChunkVecTableDimension(dbPath: string): number | undefined;
+declare function parseVecTableDimension(sql: string): number;
+/** Phase D: project_id PARTITION KEY on nodix_memory_chunk_vectors. */
+declare function vecTableDdlHasPartitionKey(sql: string): boolean;
+interface VecTableState {
+  dimension: number;
+  rowCount: number;
+  hasPartitionKey: boolean;
+}
+declare function readChunkVecTableState(db: SqliteDatabaseLike): VecTableState | undefined;
+declare function loadStorageExtensions(sqlite: SqliteRuntimeHandle): void;
+/**
+ * Startup invariant: the persisted DDL
+ * for `nodix_memory_chunks_fts` must declare `tokenize='simple ...'`. Catches DBs
+ * created against an older plugin build (still on `unicode61`) so a stale
+ * DB plus a fresh plugin doesn't silently degrade CJK recall to char-level.
+ *
+ * Mirrors the regex pattern used by `parseVecTableDimension` for
+ * `nodix_memory_chunk_vectors` — single SELECT against `sqlite_master`, regex match.
+ */
+/**
+ * Round A invariant: detect legacy DBs that pre-date migration 0004
+ * (chunk-table swap). If the parent vec/FTS objects still exist, the DB
+ * was opened against a build that never ran the new migration — fail loud
+ * so the dev wipes the file.
+ */
+declare function assertNoLegacyBoundarySchema(db: SqliteDatabaseLike): void;
+/** Implements init db as the local SQLite connection setup operation. */
+declare function initDb(dbPath: string, vectorDim: number): DrizzleDB;
+/** Implements close db as the local SQLite connection setup operation. */
+declare function closeDb(db: DrizzleDB): void;
+//#endregion
+export { initDb as a, readChunkVecTableDimension as c, validateStoragePath as d, closeDb as i, readChunkVecTableState as l, VecTableState as n, loadStorageExtensions as o, assertNoLegacyBoundarySchema as r, parseVecTableDimension as s, DrizzleDB as t, vecTableDdlHasPartitionKey as u };