@jungjaehoon/mama-core 1.4.1 → 1.5.0

package/dist/config-loader.js

@@ -29,13 +29,48 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const debug_logger_js_1 = require("./debug-logger.js");
+// Current config version — bump this when adding migrations
+const CURRENT_CONFIG_VERSION = 2;
 // Default configuration
 exports.DEFAULT_CONFIG = {
+    configVersion: CURRENT_CONFIG_VERSION,
     modelName: 'Xenova/multilingual-e5-large',
     embeddingDim: 1024,
     quantized: true,
     cacheDir: path_1.default.join(os_1.default.homedir(), '.cache', 'huggingface', 'transformers'),
 };
+/**
+ * Config migrations — each entry upgrades from (version - 1) to version.
+ * Migrations run sequentially and mutate the config object in place.
+ */
+const CONFIG_MIGRATIONS = {
+    // v1 → v2: e5-small (384-dim) → e5-large (1024-dim)
+    2: (cfg) => {
+        if (cfg.modelName === 'Xenova/multilingual-e5-small' && cfg.embeddingDim === 384) {
+            (0, debug_logger_js_1.info)('[config] Migration v2: upgrading embedding model e5-small → e5-large');
+            cfg.modelName = 'Xenova/multilingual-e5-large';
+            cfg.embeddingDim = 1024;
+        }
+    },
+};
+/**
+ * Apply pending migrations to a config object.
+ * Returns true if any migrations were applied.
+ */
+function applyMigrations(config) {
+    const startVersion = config.configVersion || 1;
+    if (startVersion >= CURRENT_CONFIG_VERSION)
+        return false;
+    for (let v = startVersion + 1; v <= CURRENT_CONFIG_VERSION; v++) {
+        const migrate = CONFIG_MIGRATIONS[v];
+        if (migrate) {
+            migrate(config);
+            (0, debug_logger_js_1.info)(`[config] Applied migration v${v}`);
+        }
+    }
+    config.configVersion = CURRENT_CONFIG_VERSION;
+    return true;
+}
 // Config file path
 const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.mama');
 const CONFIG_PATH = path_1.default.join(CONFIG_DIR, 'config.json');
@@ -80,11 +115,19 @@ function loadConfig(reload = false) {
         // Read and parse config file
         const configData = fs_1.default.readFileSync(CONFIG_PATH, 'utf8');
         const userConfig = JSON.parse(configData);
+        // Determine file's config version before merging with defaults
+        const fileVersion = userConfig.configVersion || 1;
         // Merge with defaults (user config overrides)
         const config = {
             ...exports.DEFAULT_CONFIG,
             ...userConfig,
+            configVersion: fileVersion, // preserve file version for migration check
         };
+        // Apply pending migrations based on file's version
+        if (applyMigrations(config)) {
+            fs_1.default.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
+            (0, debug_logger_js_1.info)(`[config] Migrated config saved to ${CONFIG_PATH}`);
+        }
         // Validate configuration
         if (!config.modelName || typeof config.modelName !== 'string') {
             (0, debug_logger_js_1.warn)('[config] Invalid modelName, using default:', exports.DEFAULT_CONFIG.modelName);

package/dist/connectors/event-index.d.ts

@@ -0,0 +1,44 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { ConnectorEventIndexCursorRecord, ConnectorEventIndexRecord, ConnectorEventSearchHit, ConnectorEventStalenessStatus, UpsertConnectorEventIndexCursorInput, UpsertConnectorEventIndexInput } from './types.js';
+type ConnectorEventIndexAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+interface ListConnectorEventsByDatetimeRangeInput {
+    fromMs: number;
+    toMs: number;
+    limit?: number;
+    connectors?: string[];
+    order?: 'asc' | 'desc';
+}
+interface SearchConnectorEventsOptions {
+    limit?: number;
+    connectors?: string[];
+}
+interface DeleteExpiredConnectorEventsInput {
+    nowMs: number;
+    retentionMs: number;
+    connectorName?: string;
+}
+interface StalenessOptions {
+    nowMs: number;
+    staleAfterMs?: number;
+    stalenessWarnAfterMs?: number;
+    unhealthyAfterMs?: number;
+}
+export declare function connectorEventIndexId(sourceConnector: string, sourceId: string): string;
+export declare function connectorEventContentHash(input: {
+    source_connector: string;
+    source_id: string;
+    content: string;
+    event_datetime?: number | null;
+}): Buffer;
+export declare function upsertConnectorEventIndex(adapter: ConnectorEventIndexAdapter, input: UpsertConnectorEventIndexInput): ConnectorEventIndexRecord;
+export declare function getConnectorEventIndexRecord(adapter: ConnectorEventIndexAdapter, sourceConnector: string, sourceId: string): ConnectorEventIndexRecord | null;
+export declare function listConnectorEventsByDatetimeRange(adapter: ConnectorEventIndexAdapter, input: ListConnectorEventsByDatetimeRangeInput): ConnectorEventIndexRecord[];
+export declare function searchConnectorEventsByFTS(adapter: ConnectorEventIndexAdapter, query: string, options?: SearchConnectorEventsOptions): ConnectorEventSearchHit[];
+export declare function readConnectorCursor(adapter: ConnectorEventIndexAdapter, connectorName: string): ConnectorEventIndexCursorRecord | null;
+export declare function upsertConnectorCursor(adapter: ConnectorEventIndexAdapter, input: UpsertConnectorEventIndexCursorInput): ConnectorEventIndexCursorRecord;
+export declare function deleteExpiredConnectorEvents(adapter: ConnectorEventIndexAdapter, input: DeleteExpiredConnectorEventsInput): {
+    rows_deleted: number;
+};
+export declare function computeStalenessStatus(cursor: ConnectorEventIndexCursorRecord | null, options: StalenessOptions): ConnectorEventStalenessStatus;
+export type { ConnectorEventIndexCursorRecord, ConnectorEventIndexRecord, ConnectorEventSearchHit, ConnectorEventStalenessStatus, UpsertConnectorEventIndexCursorInput, UpsertConnectorEventIndexInput, } from './types.js';
+//# sourceMappingURL=event-index.d.ts.map

package/dist/connectors/event-index.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectorEventIndexId = connectorEventIndexId;
+exports.connectorEventContentHash = connectorEventContentHash;
+exports.upsertConnectorEventIndex = upsertConnectorEventIndex;
+exports.getConnectorEventIndexRecord = getConnectorEventIndexRecord;
+exports.listConnectorEventsByDatetimeRange = listConnectorEventsByDatetimeRange;
+exports.searchConnectorEventsByFTS = searchConnectorEventsByFTS;
+exports.readConnectorCursor = readConnectorCursor;
+exports.upsertConnectorCursor = upsertConnectorCursor;
+exports.deleteExpiredConnectorEvents = deleteExpiredConnectorEvents;
+exports.computeStalenessStatus = computeStalenessStatus;
+const node_crypto_1 = require("node:crypto");
+const canonicalize_js_1 = require("../canonicalize.js");
+const DEFAULT_RANGE_LIMIT = 100;
+const DEFAULT_SEARCH_LIMIT = 25;
+const MAX_RANGE_LIMIT = 500;
+const FIVE_MINUTES_MS = 5 * 60 * 1000;
+const FIFTEEN_MINUTES_MS = 15 * 60 * 1000;
+const SIXTY_MINUTES_MS = 60 * 60 * 1000;
+function placeholders(values) {
+    if (values.length === 0) {
+        throw new Error('Cannot build SQL placeholders for an empty list.');
+    }
+    return values.map(() => '?').join(', ');
+}
+function positiveLimit(value, fallback, max = MAX_RANGE_LIMIT) {
+    if (value === undefined) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(0, Math.floor(value)));
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function eventDateFromMs(ms) {
+    if (ms === null || !Number.isFinite(ms)) {
+        return null;
+    }
+    return new Date(ms).toISOString().slice(0, 10);
+}
+function normalizeTimestampMs(input) {
+    const timestamp = input.source_timestamp_ms ?? input.event_datetime;
+    if (typeof timestamp !== 'number' || !Number.isFinite(timestamp)) {
+        throw new Error('connector_event_index.source_timestamp_ms must be a finite number.');
+    }
+    return Math.floor(timestamp);
+}
+function normalizeEventDatetime(input) {
+    if (input.event_datetime === null || input.event_datetime === undefined) {
+        return normalizeTimestampMs(input);
+    }
+    if (!Number.isFinite(input.event_datetime)) {
+        throw new Error('connector_event_index.event_datetime must be a finite number when provided.');
+    }
+    return Math.floor(input.event_datetime);
+}
+function normalizeMetadataJson(input) {
+    if (input.metadata_json !== undefined) {
+        return input.metadata_json;
+    }
+    if (input.metadata === undefined || input.metadata === null) {
+        return null;
+    }
+    return (0, canonicalize_js_1.canonicalizeJSON)(input.metadata);
+}
+function toBuffer(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    throw new Error('connector_event_index.content_hash must be a 32-byte Buffer.');
+}
+function mapConnectorEventIndexRow(row) {
+    return {
+        event_index_id: String(row.event_index_id),
+        source_connector: String(row.source_connector),
+        source_type: String(row.source_type),
+        source_id: String(row.source_id),
+        source_locator: row.source_locator === null ? null : String(row.source_locator),
+        channel: row.channel === null ? null : String(row.channel),
+        author: row.author === null ? null : String(row.author),
+        title: row.title === null ? null : String(row.title),
+        content: String(row.content),
+        event_datetime: typeof row.event_datetime === 'number' && Number.isFinite(row.event_datetime)
+            ? row.event_datetime
+            : null,
+        event_date: row.event_date === null ? null : String(row.event_date),
+        source_timestamp_ms: Number(row.source_timestamp_ms),
+        metadata_json: row.metadata_json === null ? null : String(row.metadata_json),
+        artifact_locator: row.artifact_locator === null ? null : String(row.artifact_locator),
+        artifact_title: row.artifact_title === null ? null : String(row.artifact_title),
+        content_hash: toBuffer(row.content_hash),
+        indexed_at: String(row.indexed_at),
+        updated_at: String(row.updated_at),
+        expires_at: row.expires_at === null ? null : String(row.expires_at),
+    };
+}
+function mapConnectorCursorRow(row) {
+    return {
+        connector_name: String(row.connector_name),
+        last_seen_timestamp_ms: Number(row.last_seen_timestamp_ms),
+        last_seen_source_id: String(row.last_seen_source_id),
+        last_sweep_at: row.last_sweep_at === null ? null : String(row.last_sweep_at),
+        last_success_at: row.last_success_at === null ? null : String(row.last_success_at),
+        last_error: row.last_error === null ? null : String(row.last_error),
+        last_error_at: row.last_error_at === null ? null : String(row.last_error_at),
+        indexed_count: Number(row.indexed_count),
+    };
+}
+function connectorFilterSql(connectors, alias = '') {
+    if (!connectors || connectors.length === 0) {
+        return '';
+    }
+    const prefix = alias.length > 0 ? `${alias}.` : '';
+    return ` AND ${prefix}source_connector IN (${placeholders(connectors)})`;
+}
+function hasOwn(input, key) {
+    return Object.prototype.hasOwnProperty.call(input, key);
+}
+function connectorEventIndexId(sourceConnector, sourceId) {
+    const digest = (0, node_crypto_1.createHash)('sha1').update(`${sourceConnector}\0${sourceId}`, 'utf8').digest('hex');
+    return `evt_${digest.slice(0, 16)}`;
+}
+function connectorEventContentHash(input) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update((0, canonicalize_js_1.canonicalizeJSON)({
+        source_connector: input.source_connector,
+        source_id: input.source_id,
+        content: input.content,
+        event_datetime: input.event_datetime ?? null,
+    }), 'utf8')
+        .digest();
+}
+function upsertConnectorEventIndex(adapter, input) {
+    const sourceTimestampMs = normalizeTimestampMs(input);
+    const eventDatetime = normalizeEventDatetime(input);
+    const eventDate = input.event_date ?? eventDateFromMs(eventDatetime);
+    const timestamp = input.updated_at ?? nowIso();
+    const eventIndexId = connectorEventIndexId(input.source_connector, input.source_id);
+    const contentHash = input.content_hash
+        ? Buffer.from(input.content_hash)
+        : connectorEventContentHash({
+            source_connector: input.source_connector,
+            source_id: input.source_id,
+            content: input.content,
+            event_datetime: eventDatetime,
+        });
+    if (contentHash.byteLength !== 32) {
+        throw new Error('connector_event_index.content_hash must be exactly 32 bytes.');
+    }
+    const metadataJson = normalizeMetadataJson(input);
+    return adapter.transaction(() => {
+        adapter
+            .prepare(`
+          INSERT INTO connector_event_index (
+            event_index_id, source_connector, source_type, source_id, source_locator,
+            channel, author, title, content, event_datetime, event_date, source_timestamp_ms,
+            metadata_json, artifact_locator, artifact_title, content_hash, indexed_at,
+            updated_at, expires_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(source_connector, source_id) DO UPDATE SET
+            source_type = excluded.source_type,
+            source_locator = excluded.source_locator,
+            channel = excluded.channel,
+            author = excluded.author,
+            title = excluded.title,
+            content = excluded.content,
+            event_datetime = excluded.event_datetime,
+            event_date = excluded.event_date,
+            source_timestamp_ms = excluded.source_timestamp_ms,
+            metadata_json = excluded.metadata_json,
+            artifact_locator = excluded.artifact_locator,
+            artifact_title = excluded.artifact_title,
+            content_hash = excluded.content_hash,
+            updated_at = excluded.updated_at,
+            expires_at = excluded.expires_at
+        `)
+            .run(eventIndexId, input.source_connector, input.source_type, input.source_id, input.source_locator ?? null, input.channel ?? null, input.author ?? null, input.title ?? null, input.content, eventDatetime, eventDate, sourceTimestampMs, metadataJson, input.artifact_locator ?? null, input.artifact_title ?? null, contentHash, input.indexed_at ?? timestamp, timestamp, input.expires_at ?? null);
+        const saved = getConnectorEventIndexRecord(adapter, input.source_connector, input.source_id);
+        if (!saved) {
+            throw new Error(`Failed to read connector_event_index row after upsert: ${input.source_connector}/${input.source_id}`);
+        }
+        return saved;
+    });
+}
+function getConnectorEventIndexRecord(adapter, sourceConnector, sourceId) {
+    const row = adapter
+        .prepare(`
+        SELECT *
+        FROM connector_event_index
+        WHERE source_connector = ?
+          AND source_id = ?
+        LIMIT 1
+      `)
+        .get(sourceConnector, sourceId);
+    return row ? mapConnectorEventIndexRow(row) : null;
+}
+function listConnectorEventsByDatetimeRange(adapter, input) {
+    const limit = positiveLimit(input.limit, DEFAULT_RANGE_LIMIT);
+    if (limit === 0) {
+        return [];
+    }
+    const order = input.order === 'desc' ? 'DESC' : 'ASC';
+    const connectors = input.connectors?.filter(Boolean) ?? [];
+    const params = [input.fromMs, input.toMs, ...connectors, limit];
+    const rows = adapter
+        .prepare(`
+        SELECT *
+        FROM connector_event_index
+        WHERE event_datetime >= ?
+          AND event_datetime <= ?
+          ${connectorFilterSql(connectors)}
+        ORDER BY event_datetime ${order}, event_index_id ASC
+        LIMIT ?
+      `)
+        .all(...params);
+    return rows.map(mapConnectorEventIndexRow);
+}
+function searchConnectorEventsByFTS(adapter, query, options = {}) {
+    const normalizedQuery = query.trim();
+    if (normalizedQuery.length === 0) {
+        return [];
+    }
+    const limit = positiveLimit(options.limit, DEFAULT_SEARCH_LIMIT, 100);
+    if (limit === 0) {
+        return [];
+    }
+    const connectors = options.connectors?.filter(Boolean) ?? [];
+    const params = [normalizedQuery, ...connectors, limit];
+    const rows = adapter
+        .prepare(`
+        SELECT e.*, bm25(connector_event_index_fts) AS rank
+        FROM connector_event_index_fts
+        JOIN connector_event_index e
+          ON e.event_index_id = connector_event_index_fts.event_index_id
+        WHERE connector_event_index_fts MATCH ?
+          ${connectorFilterSql(connectors, 'e')}
+        ORDER BY rank ASC, e.event_datetime DESC, e.event_index_id ASC
+        LIMIT ?
+      `)
+        .all(...params);
+    return rows.map((row) => {
+        const rank = Number(row.rank);
+        return {
+            ...mapConnectorEventIndexRow(row),
+            rank,
+            score: Number.isFinite(rank) ? 1 / (1 + Math.exp(rank)) : 0,
+        };
+    });
+}
+function readConnectorCursor(adapter, connectorName) {
+    const row = adapter
+        .prepare(`
+        SELECT *
+        FROM connector_event_index_cursors
+        WHERE connector_name = ?
+        LIMIT 1
+      `)
+        .get(connectorName);
+    return row ? mapConnectorCursorRow(row) : null;
+}
+function upsertConnectorCursor(adapter, input) {
+    const current = readConnectorCursor(adapter, input.connector_name);
+    const merged = {
+        connector_name: input.connector_name,
+        last_seen_timestamp_ms: input.last_seen_timestamp_ms ?? current?.last_seen_timestamp_ms ?? 0,
+        last_seen_source_id: input.last_seen_source_id ?? current?.last_seen_source_id ?? '',
+        last_sweep_at: hasOwn(input, 'last_sweep_at')
+            ? (input.last_sweep_at ?? null)
+            : (current?.last_sweep_at ?? null),
+        last_success_at: hasOwn(input, 'last_success_at')
+            ? (input.last_success_at ?? null)
+            : (current?.last_success_at ?? null),
+        last_error: hasOwn(input, 'last_error')
+            ? (input.last_error ?? null)
+            : (current?.last_error ?? null),
+        last_error_at: hasOwn(input, 'last_error_at')
+            ? (input.last_error_at ?? null)
+            : (current?.last_error_at ?? null),
+        indexed_count: input.indexed_count ?? current?.indexed_count ?? 0,
+    };
+    adapter
+        .prepare(`
+        INSERT INTO connector_event_index_cursors (
+          connector_name, last_seen_timestamp_ms, last_seen_source_id, last_sweep_at,
+          last_success_at, last_error, last_error_at, indexed_count
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(connector_name) DO UPDATE SET
+          last_seen_timestamp_ms = excluded.last_seen_timestamp_ms,
+          last_seen_source_id = excluded.last_seen_source_id,
+          last_sweep_at = excluded.last_sweep_at,
+          last_success_at = excluded.last_success_at,
+          last_error = excluded.last_error,
+          last_error_at = excluded.last_error_at,
+          indexed_count = excluded.indexed_count
+      `)
+        .run(merged.connector_name, merged.last_seen_timestamp_ms, merged.last_seen_source_id, merged.last_sweep_at, merged.last_success_at, merged.last_error, merged.last_error_at, merged.indexed_count);
+    const saved = readConnectorCursor(adapter, input.connector_name);
+    if (!saved) {
+        throw new Error(`Failed to read connector cursor after upsert: ${input.connector_name}`);
+    }
+    return saved;
+}
+function deleteExpiredConnectorEvents(adapter, input) {
+    if (!Number.isFinite(input.nowMs)) {
+        throw new Error('deleteExpiredConnectorEvents.nowMs must be a finite number.');
+    }
+    if (!Number.isFinite(input.retentionMs) || input.retentionMs < 0) {
+        throw new Error('deleteExpiredConnectorEvents.retentionMs must be a non-negative finite number.');
+    }
+    const cutoffMs = input.nowMs - input.retentionMs;
+    const result = input.connectorName
+        ? adapter
+            .prepare(`
+            DELETE FROM connector_event_index
+            WHERE source_connector = ?
+              AND event_datetime IS NOT NULL
+              AND event_datetime < ?
+              AND artifact_locator IS NULL
+          `)
+            .run(input.connectorName, cutoffMs)
+        : adapter
+            .prepare(`
+            DELETE FROM connector_event_index
+            WHERE event_datetime IS NOT NULL
+              AND event_datetime < ?
+              AND artifact_locator IS NULL
+          `)
+            .run(cutoffMs);
+    return { rows_deleted: result.changes };
+}
+function computeStalenessStatus(cursor, options) {
+    if (!cursor) {
+        return 'never_swept';
+    }
+    if (cursor.last_error !== null) {
+        return 'unhealthy';
+    }
+    if (cursor.last_success_at === null) {
+        return 'never_swept';
+    }
+    const lastSuccessMs = Date.parse(cursor.last_success_at);
+    if (!Number.isFinite(lastSuccessMs)) {
+        return 'unhealthy';
+    }
+    const elapsedMs = options.nowMs - lastSuccessMs;
+    const staleAfterMs = options.staleAfterMs ?? FIVE_MINUTES_MS;
+    const warnAfterMs = options.stalenessWarnAfterMs ?? FIFTEEN_MINUTES_MS;
+    const unhealthyAfterMs = options.unhealthyAfterMs ?? SIXTY_MINUTES_MS;
+    if (elapsedMs > unhealthyAfterMs) {
+        return 'unhealthy';
+    }
+    if (elapsedMs > warnAfterMs) {
+        return 'warn';
+    }
+    if (elapsedMs > staleAfterMs) {
+        return 'stale-but-warming';
+    }
+    return 'healthy';
+}
+//# sourceMappingURL=event-index.js.map

package/dist/connectors/types.d.ts

@@ -0,0 +1,69 @@
+import type { Buffer } from 'node:buffer';
+export interface ConnectorEventIndexRecord {
+    event_index_id: string;
+    source_connector: string;
+    source_type: string;
+    source_id: string;
+    source_locator: string | null;
+    channel: string | null;
+    author: string | null;
+    title: string | null;
+    content: string;
+    event_datetime: number | null;
+    event_date: string | null;
+    source_timestamp_ms: number;
+    metadata_json: string | null;
+    artifact_locator: string | null;
+    artifact_title: string | null;
+    content_hash: Buffer;
+    indexed_at: string;
+    updated_at: string;
+    expires_at: string | null;
+}
+export interface UpsertConnectorEventIndexInput {
+    source_connector: string;
+    source_type: string;
+    source_id: string;
+    source_locator?: string | null;
+    channel?: string | null;
+    author?: string | null;
+    title?: string | null;
+    content: string;
+    event_datetime?: number | null;
+    event_date?: string | null;
+    source_timestamp_ms?: number | null;
+    metadata_json?: string | null;
+    metadata?: unknown;
+    artifact_locator?: string | null;
+    artifact_title?: string | null;
+    content_hash?: Buffer | Uint8Array | null;
+    indexed_at?: string;
+    updated_at?: string;
+    expires_at?: string | null;
+}
+export interface ConnectorEventIndexCursorRecord {
+    connector_name: string;
+    last_seen_timestamp_ms: number;
+    last_seen_source_id: string;
+    last_sweep_at: string | null;
+    last_success_at: string | null;
+    last_error: string | null;
+    last_error_at: string | null;
+    indexed_count: number;
+}
+export interface UpsertConnectorEventIndexCursorInput {
+    connector_name: string;
+    last_seen_timestamp_ms?: number;
+    last_seen_source_id?: string;
+    last_sweep_at?: string | null;
+    last_success_at?: string | null;
+    last_error?: string | null;
+    last_error_at?: string | null;
+    indexed_count?: number;
+}
+export interface ConnectorEventSearchHit extends ConnectorEventIndexRecord {
+    rank: number;
+    score: number;
+}
+export type ConnectorEventStalenessStatus = 'healthy' | 'stale-but-warming' | 'warn' | 'unhealthy' | 'never_swept';
+//# sourceMappingURL=types.d.ts.map

package/dist/connectors/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/db-manager.d.ts

@@ -57,6 +57,8 @@ export interface DecisionRecord {
     edges?: DecisionEdgeRow[];
     /** ISO 8601 date when the event actually occurred. Null if not set. */
     event_date?: string | null;
+    /** Source event timestamp in milliseconds when known. Null if not set. */
+    event_datetime?: number | null;
 }
 export interface OutcomeData {
     outcome?: string | null;
@@ -202,6 +204,8 @@ export interface DecisionInput {
     risks?: string | null;
     /** ISO 8601 date string for when the event actually occurred (e.g. "2023-01-15") */
     event_date?: string | null;
+    /** Source event timestamp in milliseconds when known. */
+    event_datetime?: number | null;
 }
 /**
  * Insert decision with embedding

package/dist/db-manager.js

@@ -267,6 +267,13 @@ async function insertDecisionWithEmbedding(decision) {
             throw new Error(`Invalid event_date: must be ISO 8601 YYYY-MM-DD (got: ${d})`);
         }
     }
+    if (decision.event_datetime !== null && decision.event_datetime !== undefined) {
+        if (typeof decision.event_datetime !== 'number' ||
+            !Number.isFinite(decision.event_datetime) ||
+            decision.event_datetime <= 0) {
+            throw new Error(`Invalid event_datetime: must be a positive millisecond timestamp (got: ${decision.event_datetime})`);
+        }
+    }
     try {
         // Generate embedding BEFORE transaction (required for SQLite's sync transaction)
         // Note: Redact topic for privacy - only log length
@@ -299,14 +306,14 @@ async function insertDecisionWithEmbedding(decision) {
           confidence, created_at, updated_at,
           needs_validation, validation_attempts, last_validated_at, usage_count,
           trust_context, usage_success, usage_failure, time_saved,
-          evidence, alternatives, risks, event_date
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          evidence, alternatives, risks, event_date, event_datetime
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `);
             const insertResult = stmt.run(decision.id, decision.topic, decision.decision, decision.reasoning || null, decision.outcome || null, decision.failure_reason || null, decision.limitation || null, decision.user_involvement || null, decision.session_id || null, decision.supersedes || null, decision.superseded_by || null, decision.refined_from ? JSON.stringify(decision.refined_from) : null, decision.confidence !== undefined ? decision.confidence : 0.5, 
             // IMPORTANT: All timestamps are stored in milliseconds (Date.now()).
             // The schema DEFAULT uses unixepoch() (seconds) but is never used
             // since all inserts go through this function which always provides ms.
-            decision.created_at || Date.now(), decision.updated_at || Date.now(), decision.needs_validation !== undefined ? decision.needs_validation : 0, decision.validation_attempts || 0, decision.last_validated_at || null, decision.usage_count || 0, decision.trust_context || null, decision.usage_success || 0, decision.usage_failure || 0, decision.time_saved || 0, decision.evidence || null, decision.alternatives || null, decision.risks || null, decision.event_date || null);
+            decision.created_at || Date.now(), decision.updated_at || Date.now(), decision.needs_validation !== undefined ? decision.needs_validation : 0, decision.validation_attempts || 0, decision.last_validated_at || null, decision.usage_count || 0, decision.trust_context || null, decision.usage_success || 0, decision.usage_failure || 0, decision.time_saved || 0, decision.evidence || null, decision.alternatives || null, decision.risks || null, decision.event_date || null, decision.event_datetime ?? null);
             const rowid = Number(insertResult.lastInsertRowid);
             // Insert embedding in same transaction to ensure rowid matching
             (0, debug_logger_js_1.info)(`[db-manager] Vector search enabled: ${adapter.vectorSearchEnabled}`);

package/dist/decision-formatter.d.ts

@@ -38,6 +38,8 @@ export interface DecisionForFormat {
     risks?: string;
     /** ISO 8601 date when the event actually occurred. Null if not set. */
     event_date?: string | null;
+    /** Source event timestamp in milliseconds when known. Null if not set. */
+    event_datetime?: number | null;
 }
 /**
  * Trust context object