@jungjaehoon/mama-core 1.5.0 → 1.7.0

package/dist/db-manager.js

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initDB = initDB;
+exports.assertTestProcessIsNotUsingRealDb = assertTestProcessIsNotUsingRealDb;
 exports.getDB = getDB;
 exports.getAdapter = getAdapter;
 exports.closeDB = closeDB;
@@ -43,6 +44,7 @@ exports.isTestMode = isTestMode;
 exports.fts5Search = fts5Search;
 exports.reindexEmbeddings = reindexEmbeddings;
 const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
 const debug_logger_js_1 = require("./debug-logger.js");
 const progress_indicator_js_1 = require("./progress-indicator.js");
 const index_js_1 = require("./db-adapter/index.js");
@@ -53,6 +55,7 @@ let isInitialized = false;
 let initializingPromise = null; // Single-flight guard for concurrent callers
 // Migration directory (moved to src/db/migrations for M1.2)
 const MIGRATIONS_DIR = path_1.default.join(__dirname, '..', 'db', 'migrations');
+const REAL_USER_DB_PATH = path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
 /**
  * Initialize SQLite database adapter and connect
  *
@@ -65,6 +68,7 @@ const MIGRATIONS_DIR = path_1.default.join(__dirname, '..', 'db', 'migrations');
  * @returns SQLite database connection
  */
 async function initDB() {
+    assertTestProcessIsNotUsingRealDb();
     // Already initialized - return immediately
     if (isInitialized) {
         return dbConnection;
@@ -79,6 +83,7 @@ async function initDB() {
             (0, progress_indicator_js_1.logSearching)('Initializing database...');
             // Create SQLite adapter
             dbAdapter = (0, index_js_1.createAdapter)();
+            assertTestProcessIsNotUsingRealDb(resolveAdapterDbPath(dbAdapter), 'adapter.getDbPath()');
             // Connect to database
             dbConnection = await dbAdapter.connect();
             // Run migrations (includes 012-create-checkpoints-table.sql)
@@ -104,6 +109,48 @@ async function initDB() {
     })();
     return initializingPromise;
 }
+function assertTestProcessIsNotUsingRealDb(effectivePath, effectivePathSource = 'adapter') {
+    if (!isDatabaseBoundaryTestMode()) {
+        return;
+    }
+    const configuredPaths = [
+        { name: 'MAMA_DB_PATH', value: process.env.MAMA_DB_PATH },
+        { name: 'MAMA_DATABASE_PATH', value: process.env.MAMA_DATABASE_PATH },
+    ];
+    if (effectivePath) {
+        configuredPaths.push({ name: effectivePathSource, value: effectivePath });
+    }
+    for (const configuredPath of configuredPaths) {
+        if (!configuredPath.value) {
+            continue;
+        }
+        const resolvedPath = path_1.default.resolve(expandHomePath(configuredPath.value));
+        if (resolvedPath === path_1.default.resolve(REAL_USER_DB_PATH)) {
+            throw new Error(`[db-boundary] Refusing to initDB against real DB ${REAL_USER_DB_PATH} ` +
+                `from a test process (${configuredPath.name}=${configuredPath.value}). ` +
+                'Set MAMA_DB_PATH to a temporary path before initDB.');
+        }
+    }
+}
+function resolveAdapterDbPath(adapter) {
+    if (typeof adapter.getDbPath === 'function') {
+        return adapter.getDbPath();
+    }
+    return adapter.dbPath;
+}
+function isDatabaseBoundaryTestMode() {
+    return isTestMode();
+}
+function expandHomePath(value) {
+    const home = os_1.default.homedir();
+    if (value === '~') {
+        return home;
+    }
+    if (value.startsWith('~/')) {
+        return path_1.default.join(home, value.slice(2));
+    }
+    return value.replaceAll('${HOME}', home);
+}
 /**
  * Get database connection (singleton pattern)
  *
@@ -306,14 +353,15 @@ 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, event_datetime
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          evidence, alternatives, risks, event_date, event_datetime,
+          agent_id, model_run_id, envelope_hash, gateway_call_id, source_refs_json, provenance_json
+        ) 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.event_datetime ?? 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, decision.agent_id ?? null, decision.model_run_id ?? null, decision.envelope_hash ?? null, decision.gateway_call_id ?? null, decision.source_refs_json ?? null, decision.provenance_json ?? 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}`);
@@ -675,10 +723,10 @@ function resetDBState(options = {}) {
 /**
  * Check if running in test mode
  *
- * Returns true if MAMA_TEST_MODE or VITEST env vars are set
+ * Returns true if MAMA_TEST_MODE, VITEST, or NODE_ENV=test env vars are set
  */
 function isTestMode() {
-    return !!(process.env.MAMA_TEST_MODE || process.env.VITEST);
+    return Boolean(process.env.MAMA_TEST_MODE || process.env.VITEST || process.env.NODE_ENV === 'test');
 }
 /**
  * FTS5 keyword search on decisions table.

package/dist/edges/ref-validation.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { ListVisibleTwinEdgesOptions, TwinEdgeRecord, TwinRef, TwinScopeRef, TwinVisibility } from './types.js';
+type TwinRefVisibilityAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export declare function assertTwinRefsVisible(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], visibility?: TwinVisibility): void;
+export declare function assertTwinRefsVisibleToScopes(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], scopes?: TwinScopeRef[]): void;
+export declare function listVisibleTwinEdgesForRefs(adapter: TwinRefVisibilityAdapter, refs: readonly TwinRef[], options?: ListVisibleTwinEdgesOptions): TwinEdgeRecord[];
+export {};
+//# sourceMappingURL=ref-validation.d.ts.map

package/dist/edges/ref-validation.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertTwinRefsVisible = assertTwinRefsVisible;
+exports.assertTwinRefsVisibleToScopes = assertTwinRefsVisibleToScopes;
+exports.listVisibleTwinEdgesForRefs = listVisibleTwinEdgesForRefs;
+const store_js_1 = require("./store.js");
+const TABLE_COLUMN_PRAGMAS = {
+    decisions: 'PRAGMA table_info(decisions)',
+    case_truth: 'PRAGMA table_info(case_truth)',
+};
+const tableColumnCache = new WeakMap();
+// Keep memory-truth quarantine semantics excluded for legacy/backcompat rows even though the
+// current decisions.status CHECK only admits superseded/contradicted/stale terminal states.
+const EXCLUDED_MEMORY_STATUSES = new Set(['superseded', 'quarantined', 'contradicted', 'stale']);
+function scopeKey(scope) {
+    return `${scope.kind}\0${scope.id}`;
+}
+function hasScopes(scopes) {
+    return Array.isArray(scopes) && scopes.length > 0;
+}
+function hasProjectRefs(projectRefs) {
+    return Array.isArray(projectRefs) && projectRefs.length > 0;
+}
+function visibilityFromScopes(scopes) {
+    return { scopes: scopes ? [...scopes] : undefined };
+}
+function asOfMs(visibility) {
+    return typeof visibility.asOfMs === 'number' ? visibility.asOfMs : null;
+}
+function startMs(visibility) {
+    return typeof visibility.startMs === 'number' ? visibility.startMs : null;
+}
+function isWithinVisibilityTime(value, visibility) {
+    const start = startMs(visibility);
+    const asOf = asOfMs(visibility);
+    if (start === null && asOf === null) {
+        return true;
+    }
+    return (typeof value === 'number' &&
+        (start === null || value >= start) &&
+        (asOf === null || value <= asOf));
+}
+function parseTimestamp(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return null;
+        }
+        const numeric = Number(trimmed);
+        if (Number.isFinite(numeric)) {
+            return Math.floor(numeric);
+        }
+        const parsed = Date.parse(trimmed);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function tableColumns(adapter, table) {
+    const pragma = TABLE_COLUMN_PRAGMAS[table];
+    if (!pragma) {
+        throw new Error(`Unsupported table for column introspection: ${table}`);
+    }
+    let adapterCache = tableColumnCache.get(adapter);
+    if (!adapterCache) {
+        adapterCache = new Map();
+        tableColumnCache.set(adapter, adapterCache);
+    }
+    const cached = adapterCache.get(table);
+    if (cached) {
+        return cached;
+    }
+    const rows = adapter.prepare(pragma).all();
+    const columns = new Set(rows.map((row) => row.name));
+    adapterCache.set(table, columns);
+    return columns;
+}
+function isMemoryVisible(adapter, id, visibility) {
+    const columns = tableColumns(adapter, 'decisions');
+    const statusSelect = columns.has('status') ? 'status' : 'NULL AS status';
+    const supersededBySelect = columns.has('superseded_by')
+        ? 'superseded_by'
+        : 'NULL AS superseded_by';
+    const row = adapter
+        .prepare(`
+        SELECT created_at, event_datetime, ${statusSelect}, ${supersededBySelect}
+        FROM decisions
+        WHERE id = ?
+        LIMIT 1
+      `)
+        .get(id);
+    if (!row) {
+        return false;
+    }
+    const status = typeof row.status === 'string' ? row.status : 'active';
+    if (EXCLUDED_MEMORY_STATUSES.has(status) ||
+        (typeof row.superseded_by === 'string' && row.superseded_by.length > 0)) {
+        return false;
+    }
+    if (!isWithinVisibilityTime(row.event_datetime ?? row.created_at, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    const scopeClauses = scopes.map(() => '(ms.kind = ? AND ms.external_id = ?)').join(' OR ');
+    const params = scopes.flatMap((scope) => [scope.kind, scope.id]);
+    const bindingRow = adapter
+        .prepare(`
+        SELECT 1 AS ok
+        FROM memory_scope_bindings msb
+        JOIN memory_scopes ms ON ms.id = msb.scope_id
+        WHERE msb.memory_id = ?
+          AND (${scopeClauses})
+        LIMIT 1
+      `)
+        .get(id, ...params);
+    if (bindingRow?.ok) {
+        return true;
+    }
+    if (columns.has('memory_scope_kind') && columns.has('memory_scope_id')) {
+        const row = adapter
+            .prepare(`
+          SELECT 1 AS ok
+          FROM decisions
+          WHERE id = ?
+            AND (${scopes.map(() => '(memory_scope_kind = ? AND memory_scope_id = ?)').join(' OR ')})
+          LIMIT 1
+        `)
+            .get(id, ...params);
+        return Boolean(row?.ok);
+    }
+    return false;
+}
+function parseCaseScopeRefs(scopeRefs) {
+    if (typeof scopeRefs !== 'string' || scopeRefs.length === 0) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(scopeRefs);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.filter((item) => item !== null &&
+            typeof item === 'object' &&
+            typeof item.kind === 'string' &&
+            typeof item.id === 'string');
+    }
+    catch {
+        return [];
+    }
+}
+function isCaseVisible(adapter, id, visibility) {
+    const row = adapter.prepare('SELECT * FROM case_truth WHERE case_id = ? LIMIT 1').get(id);
+    if (!row) {
+        return false;
+    }
+    const timestamp = parseTimestamp(row.last_activity_at) ?? parseTimestamp(row.updated_at);
+    if (!isWithinVisibilityTime(timestamp, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    const requested = new Set(scopes.map(scopeKey));
+    const scopeRefs = parseCaseScopeRefs(row.scope_refs);
+    if (scopeRefs.some((scope) => requested.has(scopeKey(scope)))) {
+        return true;
+    }
+    const columns = tableColumns(adapter, 'case_truth');
+    if (columns.has('memory_scope_kind') && columns.has('memory_scope_id')) {
+        return scopes.some((scope) => row.memory_scope_kind === scope.kind && row.memory_scope_id === scope.id);
+    }
+    return false;
+}
+function isRawVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare('SELECT * FROM connector_event_index WHERE event_index_id = ? LIMIT 1')
+        .get(id);
+    if (!row) {
+        return false;
+    }
+    if (Array.isArray(visibility.connectors) &&
+        !visibility.connectors.includes(String(row.source_connector))) {
+        return false;
+    }
+    if (hasProjectRefs(visibility.projectRefs) &&
+        !visibility.projectRefs.some((project) => project.id === row.project_id)) {
+        return false;
+    }
+    if (typeof visibility.tenantId === 'string' &&
+        visibility.tenantId.length > 0 &&
+        row.tenant_id !== visibility.tenantId) {
+        return false;
+    }
+    const rawTs = row.event_datetime ?? row.source_timestamp_ms;
+    if (rawTs === null || rawTs === undefined || (typeof rawTs === 'string' && rawTs.trim() === '')) {
+        return false;
+    }
+    const eventTsMs = parseTimestamp(rawTs);
+    if (eventTsMs === null || eventTsMs < 0 || !isWithinVisibilityTime(eventTsMs, visibility)) {
+        return false;
+    }
+    if (!hasScopes(visibility.scopes)) {
+        return true;
+    }
+    return visibility.scopes.some((scope) => row.memory_scope_kind === scope.kind && row.memory_scope_id === scope.id);
+}
+function isEntityVisible(adapter, id, visibility) {
+    const row = adapter
+        .prepare('SELECT scope_kind, scope_id, created_at FROM entity_nodes WHERE id = ? AND status = ? LIMIT 1')
+        .get(id, 'active');
+    if (!row) {
+        return false;
+    }
+    if (!isWithinVisibilityTime(row.created_at, visibility)) {
+        return false;
+    }
+    const scopes = visibility.scopes;
+    if (!hasScopes(scopes)) {
+        return true;
+    }
+    return scopes.some((scope) => row.scope_kind === scope.kind && row.scope_id === scope.id);
+}
+function isTwinRefVisible(adapter, ref, visibility, visitedEdges, edgeCache) {
+    if (ref.kind === 'entity') {
+        return isEntityVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'report') {
+        return !hasScopes(visibility.scopes);
+    }
+    if (ref.kind === 'memory') {
+        return isMemoryVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'case') {
+        return isCaseVisible(adapter, ref.id, visibility);
+    }
+    if (ref.kind === 'raw') {
+        return isRawVisible(adapter, ref.id, visibility);
+    }
+    if (visitedEdges.has(ref.id)) {
+        return false;
+    }
+    let edge = edgeCache.get(ref.id);
+    if (edge === undefined) {
+        edge = (0, store_js_1.getTwinEdge)(adapter, ref.id);
+        edgeCache.set(ref.id, edge);
+    }
+    if (!edge) {
+        return false;
+    }
+    if (!isWithinVisibilityTime(edge.created_at, visibility)) {
+        return false;
+    }
+    const pathWithCurrent = new Set(visitedEdges);
+    pathWithCurrent.add(ref.id);
+    return (isTwinRefVisible(adapter, edge.subject_ref, visibility, new Set(pathWithCurrent), edgeCache) &&
+        isTwinRefVisible(adapter, edge.object_ref, visibility, new Set(pathWithCurrent), edgeCache));
+}
+function assertTwinRefsVisible(adapter, refs, visibility = {}) {
+    const edgeCache = new Map();
+    for (const ref of refs) {
+        if (!isTwinRefVisible(adapter, ref, visibility, new Set(), edgeCache)) {
+            throw new Error(`Twin ref is not visible to requested visibility: ${ref.kind}:${ref.id}`);
+        }
+    }
+}
+function assertTwinRefsVisibleToScopes(adapter, refs, scopes) {
+    assertTwinRefsVisible(adapter, refs, visibilityFromScopes(scopes));
+}
+function listVisibleTwinEdgesForRefs(adapter, refs, options = {}) {
+    const edgeCache = new Map();
+    const edgeTypes = normalizeEdgeTypes(options.edgeTypes);
+    const edges = (0, store_js_1.listTwinEdgesForRefs)(adapter, refs).filter((edge) => (edgeTypes.size === 0 || edgeTypes.has(edge.edge_type)) &&
+        (typeof options.startMs !== 'number' || edge.created_at >= options.startMs) &&
+        (typeof options.asOfMs !== 'number' || edge.created_at <= options.asOfMs) &&
+        isTwinRefVisible(adapter, edge.subject_ref, options, new Set(), edgeCache) &&
+        isTwinRefVisible(adapter, edge.object_ref, options, new Set(), edgeCache));
+    const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+        ? Math.max(0, Math.floor(options.limit))
+        : null;
+    const sortedEdges = [...edges].sort((left, right) => {
+        const createdDiff = right.created_at - left.created_at;
+        return createdDiff !== 0 ? createdDiff : left.edge_id.localeCompare(right.edge_id);
+    });
+    if (limit === null) {
+        return sortedEdges;
+    }
+    return sortedEdges.slice(0, limit);
+}
+function normalizeEdgeTypes(edgeTypes) {
+    if (!Array.isArray(edgeTypes) || edgeTypes.length === 0) {
+        return new Set();
+    }
+    return new Set(edgeTypes);
+}
+//# sourceMappingURL=ref-validation.js.map

package/dist/edges/store.d.ts

@@ -0,0 +1,10 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import { type InsertTwinEdgeInput, type TwinEdgeRecord, type TwinRef } from './types.js';
+type TwinEdgeReadAdapter = Pick<DatabaseAdapter, 'prepare'>;
+type TwinEdgeAdapter = Pick<DatabaseAdapter, 'prepare' | 'transaction'>;
+export declare function mapTwinEdgeRow(row: Record<string, unknown>): TwinEdgeRecord;
+export declare function getTwinEdge(adapter: TwinEdgeReadAdapter, edgeId: string): TwinEdgeRecord | null;
+export declare function listTwinEdgesForRefs(adapter: TwinEdgeReadAdapter, refs: readonly TwinRef[]): TwinEdgeRecord[];
+export declare function insertTwinEdge(adapter: TwinEdgeAdapter, input: InsertTwinEdgeInput): TwinEdgeRecord;
+export {};
+//# sourceMappingURL=store.d.ts.map