@jungjaehoon/mama-core 1.1.2 → 1.1.3

package/dist/embeddings.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Embedding Generation
+ *
+ * Story M1.4: Configurable embedding model selection
+ * Generates embeddings using configurable model (default: multilingual-e5-small)
+ * Supports: Korean-English cross-lingual similarity, enhanced metadata
+ *
+ * @module embeddings
+ * @version 1.1
+ * @date 2025-11-20
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmbeddingDim = exports.getModelName = exports.loadConfig = exports.MODEL_NAME = exports.EMBEDDING_DIM = exports.embeddingCache = void 0;
+exports.generateEmbedding = generateEmbedding;
+exports.generateEnhancedEmbedding = generateEnhancedEmbedding;
+exports.generateBatchEmbeddings = generateBatchEmbeddings;
+exports.cosineSimilarity = cosineSimilarity;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const debug_logger_js_1 = require("./debug-logger.js");
+const progress_indicator_js_1 = require("./progress-indicator.js");
+const embedding_cache_js_1 = require("./embedding-cache.js");
+Object.defineProperty(exports, "embeddingCache", { enumerable: true, get: function () { return embedding_cache_js_1.embeddingCache; } });
+const config_loader_js_1 = require("./config-loader.js");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return config_loader_js_1.loadConfig; } });
+Object.defineProperty(exports, "getModelName", { enumerable: true, get: function () { return config_loader_js_1.getModelName; } });
+Object.defineProperty(exports, "getEmbeddingDim", { enumerable: true, get: function () { return config_loader_js_1.getEmbeddingDim; } });
+// Shared cache directory (not in node_modules)
+const DEFAULT_CACHE_DIR = path_1.default.join(os_1.default.homedir(), '.cache', 'huggingface', 'transformers');
+// Singleton pattern for model loading
+let embeddingPipeline = null;
+let currentModelName = null;
+let modelLoadFailed = false; // Cache load failures to avoid repeated slow retries
+/**
+ * Load embedding model (configurable)
+ *
+ * Story M1.4 AC #2: Transformers.js singleton initialization
+ * Story M1.4 AC #3: Changing model via config triggers informative log + resets caches
+ *
+ * @returns Embedding pipeline
+ */
+async function loadModel() {
+    const modelName = (0, config_loader_js_1.getModelName)();
+    // Check if model has changed (Story M1.4 AC #3)
+    if (embeddingPipeline && currentModelName && currentModelName !== modelName) {
+        (0, debug_logger_js_1.info)('[MAMA] ⚠️  Embedding model changed - resetting pipeline');
+        (0, debug_logger_js_1.info)(`[MAMA] Old model: ${currentModelName}`);
+        (0, debug_logger_js_1.info)(`[MAMA] New model: ${modelName}`);
+        // Reset pipeline and cache
+        embeddingPipeline = null;
+        currentModelName = null;
+        embedding_cache_js_1.embeddingCache.clear();
+        (0, debug_logger_js_1.info)('[MAMA] ⚡ Model cache cleared');
+    }
+    // Fail fast if a previous load attempt already failed (avoid repeated slow retries)
+    if (modelLoadFailed) {
+        throw new Error('Embedding model previously failed to load — skipping retry');
+    }
+    // Load model if not already loaded
+    if (!embeddingPipeline) {
+        (0, progress_indicator_js_1.logLoading)(`Loading embedding model: ${modelName}...`);
+        const startTime = Date.now();
+        try {
+            // Dynamic import for ES Module compatibility (Railway deployment)
+            const transformers = await import('@huggingface/transformers');
+            const { pipeline, env } = transformers;
+            // Set shared cache directory (not in node_modules)
+            // This prevents re-downloading models on every npm install
+            const cacheDir = process.env.HF_HOME || process.env.TRANSFORMERS_CACHE || DEFAULT_CACHE_DIR;
+            env.cacheDir = cacheDir;
+            (0, debug_logger_js_1.info)(`[MAMA] Model cache directory: ${cacheDir}`);
+            embeddingPipeline = (await pipeline('feature-extraction', modelName));
+            currentModelName = modelName;
+            const loadTime = Date.now() - startTime;
+            const config = (0, config_loader_js_1.loadConfig)();
+            (0, progress_indicator_js_1.logComplete)(`Embedding model ready (${loadTime}ms, ${config.embeddingDim}-dim)`);
+        }
+        catch (loadErr) {
+            modelLoadFailed = true;
+            throw loadErr;
+        }
+    }
+    return embeddingPipeline;
+}
+/**
+ * Generate embedding vector from text
+ *
+ * Story M1.4 AC #1: Uses configurable embeddingDim from config
+ * Target: < 30ms latency
+ *
+ * @param text - Input text to embed
+ * @returns Embedding vector (dimension from config)
+ * @throws Error if text is empty or embedding fails
+ */
+async function generateEmbedding(text) {
+    if (!text || text.trim().length === 0) {
+        throw new Error('Text cannot be empty');
+    }
+    // Task 2: Check cache first (AC #3)
+    const cached = embedding_cache_js_1.embeddingCache.get(text);
+    if (cached) {
+        return cached;
+    }
+    const startTime = Date.now();
+    try {
+        const model = await loadModel();
+        const expectedDim = (0, config_loader_js_1.getEmbeddingDim)();
+        // Generate embedding
+        const output = await model(text, {
+            pooling: 'mean', // Mean pooling over tokens
+            normalize: true, // L2 normalization
+        });
+        // Extract Float32Array
+        const embedding = output.data;
+        // Verify dimensions match config
+        if (embedding.length !== expectedDim) {
+            throw new Error(`Expected ${expectedDim}-dim, got ${embedding.length}-dim`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const _latency = Date.now() - startTime;
+        // Task 2: Store in cache (AC #3)
+        embedding_cache_js_1.embeddingCache.set(text, embedding);
+        return embedding;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to generate embedding: ${message}`);
+    }
+}
+/**
+ * Generate enhanced embedding with content + metadata
+ *
+ * Task 3.4: Implement enhanced embedding format
+ * Inspired by A-mem: Content + Metadata for richer semantic representation
+ *
+ * @param decision - Decision object
+ * @returns 384-dim enhanced embedding
+ */
+async function generateEnhancedEmbedding(decision) {
+    // Construct enriched text representation with narrative fields (Story 2.2)
+    const parts = [
+        `Topic: ${decision.topic}`,
+        `Decision: ${decision.decision}`,
+        `Reasoning: ${decision.reasoning || 'N/A'}`,
+        `Outcome: ${decision.outcome || 'ONGOING'}`,
+        `Confidence: ${decision.confidence !== undefined ? decision.confidence : 0.5}`,
+        `User Involvement: ${decision.user_involvement || 'N/A'}`,
+    ];
+    // Add narrative fields if present (Story 2.2: Narrative-Based Search)
+    if (decision.evidence) {
+        const evidenceText = Array.isArray(decision.evidence)
+            ? decision.evidence.join('; ')
+            : typeof decision.evidence === 'string'
+                ? decision.evidence
+                : JSON.stringify(decision.evidence);
+        parts.push(`Evidence: ${evidenceText}`);
+    }
+    if (decision.alternatives) {
+        const alternativesText = Array.isArray(decision.alternatives)
+            ? decision.alternatives.join('; ')
+            : typeof decision.alternatives === 'string'
+                ? decision.alternatives
+                : JSON.stringify(decision.alternatives);
+        parts.push(`Alternatives: ${alternativesText}`);
+    }
+    if (decision.risks) {
+        parts.push(`Risks: ${decision.risks}`);
+    }
+    const enrichedText = parts.join('\n').trim();
+    return generateEmbedding(enrichedText);
+}
+/**
+ * Batch generate embeddings (optimized)
+ *
+ * Task 1: Implement Batch Embedding Generation
+ * AC #3: Target - 30ms for 10 embeddings (vs 300ms sequential)
+ *
+ * Strategy: Use native transformer batch processing for parallel inference
+ *
+ * @param texts - Array of texts to embed (max 10 per batch)
+ * @returns Array of embeddings
+ */
+async function generateBatchEmbeddings(texts) {
+    if (!Array.isArray(texts) || texts.length === 0) {
+        throw new Error('Texts must be a non-empty array');
+    }
+    // Validate all texts
+    for (const text of texts) {
+        if (!text || text.trim().length === 0) {
+            throw new Error('All texts must be non-empty');
+        }
+    }
+    const startTime = Date.now();
+    try {
+        const model = await loadModel();
+        const expectedDim = (0, config_loader_js_1.getEmbeddingDim)();
+        // Native batch processing - single model forward pass
+        // This is significantly faster than sequential calls
+        const outputs = await model(texts, {
+            pooling: 'mean',
+            normalize: true,
+        });
+        // Extract embeddings from batch output
+        const embeddings = [];
+        const batchSize = texts.length;
+        for (let i = 0; i < batchSize; i++) {
+            // Each embedding is expectedDim consecutive elements
+            const start = i * expectedDim;
+            const end = start + expectedDim;
+            const embedding = outputs.data.slice(start, end);
+            // Verify dimensions
+            if (embedding.length !== expectedDim) {
+                throw new Error(`Expected ${expectedDim}-dim, got ${embedding.length}-dim at index ${i}`);
+            }
+            embeddings.push(embedding);
+        }
+        const latency = Date.now() - startTime;
+        const avgLatency = latency / batchSize;
+        // Log for performance tracking
+        if (process.env.MAMA_DEBUG) {
+            (0, debug_logger_js_1.info)(`[MAMA] Batch(${batchSize}) embeddings: ${latency}ms total (${avgLatency.toFixed(1)}ms avg)`);
+        }
+        return embeddings;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to generate batch embeddings: ${message}`);
+    }
+}
+/**
+ * Calculate cosine similarity between two embeddings
+ *
+ * Utility for testing and validation
+ *
+ * @param embA - First embedding
+ * @param embB - Second embedding
+ * @returns Cosine similarity (0-1)
+ */
+function cosineSimilarity(embA, embB) {
+    if (embA.length !== embB.length) {
+        throw new Error('Embeddings must have same dimension');
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < embA.length; i++) {
+        dotProduct += embA[i] * embB[i];
+        normA += embA[i] * embA[i];
+        normB += embB[i] * embB[i];
+    }
+    const similarity = dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    return similarity;
+}
+// Static snapshots of config values at module load time (Story M1.4)
+// Note: These are evaluated once at import time. Use getEmbeddingDim()/getModelName() for runtime values.
+exports.EMBEDDING_DIM = (0, config_loader_js_1.getEmbeddingDim)();
+exports.MODEL_NAME = (0, config_loader_js_1.getModelName)();
+//# sourceMappingURL=embeddings.js.map

package/dist/errors.d.ts

@@ -0,0 +1,131 @@
+/**
+ * MAMA Error Classes - Typed Error Handling
+ *
+ * Story 8.3: Typed Error Classes
+ * Provides consistent error handling across MCP tools and core modules
+ *
+ * Error codes follow MCP standard response format:
+ * {error: {code: 'ERROR_CODE', message: '...', details: {}}}
+ *
+ * @module errors
+ * @version 1.0
+ */
+export interface ErrorDetails {
+    [key: string]: unknown;
+}
+export interface ErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        details: ErrorDetails;
+    };
+}
+export interface ErrorJSON {
+    name: string;
+    code: string;
+    message: string;
+    details: ErrorDetails;
+    timestamp: string;
+    stack?: string;
+}
+/**
+ * Base error class for all MAMA errors
+ */
+export declare class MAMAError extends Error {
+    code: string;
+    details: ErrorDetails;
+    timestamp: string;
+    constructor(message: string, code?: string, details?: ErrorDetails);
+    /**
+     * Convert to MCP-compatible error response format
+     */
+    toResponse(): ErrorResponse;
+    /**
+     * Convert to JSON for logging
+     */
+    toJSON(): ErrorJSON;
+}
+/**
+ * Error thrown when a decision is not found
+ */
+export declare class NotFoundError extends MAMAError {
+    constructor(resourceType: string, identifier: string, details?: ErrorDetails);
+}
+/**
+ * Error thrown when input validation fails
+ */
+export declare class ValidationError extends MAMAError {
+    field: string;
+    constructor(field: string, message: string, received?: unknown, details?: ErrorDetails);
+}
+/**
+ * Error thrown when database operations fail
+ */
+export declare class DatabaseError extends MAMAError {
+    operation: string;
+    constructor(operation: string, message: string, details?: ErrorDetails);
+}
+/**
+ * Error thrown when embedding generation fails
+ */
+export declare class EmbeddingError extends MAMAError {
+    constructor(message: string, details?: ErrorDetails);
+}
+/**
+ * Error thrown when configuration is invalid
+ */
+export declare class ConfigurationError extends MAMAError {
+    configKey: string;
+    constructor(configKey: string, message: string, details?: ErrorDetails);
+}
+/**
+ * Error thrown when a link operation fails
+ */
+export declare class LinkError extends MAMAError {
+    operation: string;
+    constructor(operation: string, message: string, details?: ErrorDetails);
+}
+/**
+ * Error thrown when rate limit is exceeded
+ */
+export declare class RateLimitError extends MAMAError {
+    retryAfterMs: number;
+    constructor(operation: string, retryAfterMs: number, details?: ErrorDetails);
+}
+/**
+ * Error thrown when operation times out
+ */
+export declare class TimeoutError extends MAMAError {
+    timeoutMs: number;
+    constructor(operation: string, timeoutMs: number, details?: ErrorDetails);
+}
+/**
+ * Error codes enum for reference
+ */
+export declare const ErrorCodes: {
+    readonly DECISION_NOT_FOUND: "DECISION_NOT_FOUND";
+    readonly CHECKPOINT_NOT_FOUND: "CHECKPOINT_NOT_FOUND";
+    readonly LINK_NOT_FOUND: "LINK_NOT_FOUND";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD";
+    readonly INVALID_FORMAT: "INVALID_FORMAT";
+    readonly DATABASE_ERROR: "DATABASE_ERROR";
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly QUERY_FAILED: "QUERY_FAILED";
+    readonly EMBEDDING_ERROR: "EMBEDDING_ERROR";
+    readonly CONFIG_ERROR: "CONFIG_ERROR";
+    readonly LINK_ERROR: "LINK_ERROR";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+};
+export type ErrorCode = (typeof ErrorCodes)[keyof typeof ErrorCodes];
+/**
+ * Helper function to wrap unknown errors
+ */
+export declare function wrapError(error: unknown, context?: string): MAMAError;
+/**
+ * Helper function to check if an error is a MAMA error
+ */
+export declare function isMAMAError(error: unknown): error is MAMAError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * MAMA Error Classes - Typed Error Handling
+ *
+ * Story 8.3: Typed Error Classes
+ * Provides consistent error handling across MCP tools and core modules
+ *
+ * Error codes follow MCP standard response format:
+ * {error: {code: 'ERROR_CODE', message: '...', details: {}}}
+ *
+ * @module errors
+ * @version 1.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodes = exports.TimeoutError = exports.RateLimitError = exports.LinkError = exports.ConfigurationError = exports.EmbeddingError = exports.DatabaseError = exports.ValidationError = exports.NotFoundError = exports.MAMAError = void 0;
+exports.wrapError = wrapError;
+exports.isMAMAError = isMAMAError;
+/**
+ * Base error class for all MAMA errors
+ */
+class MAMAError extends Error {
+    code;
+    details;
+    timestamp;
+    constructor(message, code = 'MAMA_ERROR', details = {}) {
+        super(message);
+        this.name = 'MAMAError';
+        this.code = code;
+        this.details = details;
+        this.timestamp = new Date().toISOString();
+        // Capture stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Convert to MCP-compatible error response format
+     */
+    toResponse() {
+        return {
+            error: {
+                code: this.code,
+                message: this.message,
+                details: this.details,
+            },
+        };
+    }
+    /**
+     * Convert to JSON for logging
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            details: this.details,
+            timestamp: this.timestamp,
+            stack: this.stack,
+        };
+    }
+}
+exports.MAMAError = MAMAError;
+/**
+ * Error thrown when a decision is not found
+ */
+class NotFoundError extends MAMAError {
+    constructor(resourceType, identifier, details = {}) {
+        super(`${resourceType} not found: ${identifier}`, `${resourceType.toUpperCase()}_NOT_FOUND`, {
+            resourceType,
+            identifier,
+            ...details,
+        });
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Error thrown when input validation fails
+ */
+class ValidationError extends MAMAError {
+    field;
+    constructor(field, message, received, details = {}) {
+        super(`Validation failed for '${field}': ${message}`, 'INVALID_INPUT', {
+            field,
+            received: received !== undefined ? String(received).substring(0, 100) : undefined,
+            ...details,
+        });
+        this.name = 'ValidationError';
+        this.field = field;
+    }
+}
+exports.ValidationError = ValidationError;
+/**
+ * Error thrown when database operations fail
+ */
+class DatabaseError extends MAMAError {
+    operation;
+    constructor(operation, message, details = {}) {
+        super(`Database ${operation} failed: ${message}`, 'DATABASE_ERROR', {
+            operation,
+            ...details,
+        });
+        this.name = 'DatabaseError';
+        this.operation = operation;
+    }
+}
+exports.DatabaseError = DatabaseError;
+/**
+ * Error thrown when embedding generation fails
+ */
+class EmbeddingError extends MAMAError {
+    constructor(message, details = {}) {
+        super(`Embedding generation failed: ${message}`, 'EMBEDDING_ERROR', details);
+        this.name = 'EmbeddingError';
+    }
+}
+exports.EmbeddingError = EmbeddingError;
+/**
+ * Error thrown when configuration is invalid
+ */
+class ConfigurationError extends MAMAError {
+    configKey;
+    constructor(configKey, message, details = {}) {
+        super(`Configuration error for '${configKey}': ${message}`, 'CONFIG_ERROR', {
+            configKey,
+            ...details,
+        });
+        this.name = 'ConfigurationError';
+        this.configKey = configKey;
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+/**
+ * Error thrown when a link operation fails
+ */
+class LinkError extends MAMAError {
+    operation;
+    constructor(operation, message, details = {}) {
+        super(`Link ${operation} failed: ${message}`, 'LINK_ERROR', {
+            operation,
+            ...details,
+        });
+        this.name = 'LinkError';
+        this.operation = operation;
+    }
+}
+exports.LinkError = LinkError;
+/**
+ * Error thrown when rate limit is exceeded
+ */
+class RateLimitError extends MAMAError {
+    retryAfterMs;
+    constructor(operation, retryAfterMs, details = {}) {
+        super(`Rate limit exceeded for ${operation}. Retry after ${retryAfterMs}ms`, 'RATE_LIMITED', {
+            operation,
+            retryAfterMs,
+            ...details,
+        });
+        this.name = 'RateLimitError';
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.RateLimitError = RateLimitError;
+/**
+ * Error thrown when operation times out
+ */
+class TimeoutError extends MAMAError {
+    timeoutMs;
+    constructor(operation, timeoutMs, details = {}) {
+        super(`Operation '${operation}' timed out after ${timeoutMs}ms`, 'TIMEOUT', {
+            operation,
+            timeoutMs,
+            ...details,
+        });
+        this.name = 'TimeoutError';
+        this.timeoutMs = timeoutMs;
+    }
+}
+exports.TimeoutError = TimeoutError;
+/**
+ * Error codes enum for reference
+ */
+exports.ErrorCodes = {
+    // Resource errors
+    DECISION_NOT_FOUND: 'DECISION_NOT_FOUND',
+    CHECKPOINT_NOT_FOUND: 'CHECKPOINT_NOT_FOUND',
+    LINK_NOT_FOUND: 'LINK_NOT_FOUND',
+    // Validation errors
+    INVALID_INPUT: 'INVALID_INPUT',
+    MISSING_REQUIRED_FIELD: 'MISSING_REQUIRED_FIELD',
+    INVALID_FORMAT: 'INVALID_FORMAT',
+    // Database errors
+    DATABASE_ERROR: 'DATABASE_ERROR',
+    CONNECTION_FAILED: 'CONNECTION_FAILED',
+    QUERY_FAILED: 'QUERY_FAILED',
+    // Processing errors
+    EMBEDDING_ERROR: 'EMBEDDING_ERROR',
+    CONFIG_ERROR: 'CONFIG_ERROR',
+    LINK_ERROR: 'LINK_ERROR',
+    // Operational errors
+    RATE_LIMITED: 'RATE_LIMITED',
+    TIMEOUT: 'TIMEOUT',
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+};
+/**
+ * Helper function to wrap unknown errors
+ */
+function wrapError(error, context = 'Unknown operation') {
+    if (error instanceof MAMAError) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : undefined;
+    return new MAMAError(`${context}: ${message}`, 'INTERNAL_ERROR', {
+        originalError: message,
+        originalStack: stack,
+    });
+}
+/**
+ * Helper function to check if an error is a MAMA error
+ */
+function isMAMAError(error) {
+    return error instanceof MAMAError;
+}
+//# sourceMappingURL=errors.js.map

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * MAMA Core - Main exports
+ *
+ * Shared modules for Memory-Augmented MCP Assistant.
+ * Used by mcp-server, claude-code-plugin, and standalone packages.
+ *
+ * @module mama-core
+ * @version 1.0.0
+ */
+export { generateEmbedding, generateEnhancedEmbedding, generateBatchEmbeddings, cosineSimilarity, embeddingCache, EMBEDDING_DIM, MODEL_NAME, } from './embeddings.js';
+export { EmbeddingCache } from './embedding-cache.js';
+export { getEmbeddingFromServer, getServerStatus, isServerRunning, getServerPort, DEFAULT_PORT, HOST, TIMEOUT_MS, type ServerStatus, } from './embedding-client.js';
+export { initDB, getDB, getAdapter, closeDB, insertEmbedding, vectorSearch, queryVectorSearch, insertDecisionWithEmbedding, queryDecisionGraph, querySemanticEdges, updateDecisionOutcome, getPreparedStmt, getDbPath, type DatabaseAdapter as DBManagerAdapter, type PreparedStatement, type DecisionRecord, type OutcomeData, type VectorSearchParams, type SemanticEdges, type DecisionInput, } from './db-manager.js';
+export { createAdapter, DatabaseAdapter, SQLiteAdapter, type AdapterConfig, type Statement, type VectorSearchResult, type RunResult, } from './db-adapter/index.js';
+export { getSessionDecisions, incrementUsageSuccess, incrementUsageFailure, getDecisionById, traverseDecisionChain, DB_PATH, DB_DIR, LEGACY_DB_PATH, DEFAULT_DB_PATH, } from './memory-store.js';
+import mama from './mama-api.js';
+export { mama };
+export { loadConfig, getModelName, getEmbeddingDim, getCacheDir, updateConfig, getConfigPath, DEFAULT_CONFIG, type MAMAConfig, type ConfigUpdates, } from './config-loader.js';
+export { calculateRelevance, selectTopDecisions, formatTopNContext, testRelevanceScoring, type DecisionWithEmbedding, type QueryContext, type FormattedContext, type TestResult, } from './relevance-scorer.js';
+export { learnDecision, generateDecisionId, getPreviousDecision, createEdge, createSupersedesEdge, markSuperseded, calculateCombinedConfidence, detectRefinement, parseReasoningForRelationships, createEdgesFromReasoning, getSupersededChainDepth, updateConfidence, VALID_EDGE_TYPES, type EdgeType, type DecisionDetection, type ToolExecution, type SessionContext, type LearnDecisionResult, type ParsedRelationship, type EvidenceItem, } from './decision-tracker.js';
+export { validateTier, checkNodeVersion, checkSQLite, checkEmbeddings, checkDatabase, getTierDescription, getTierBanner, type TierValidation, type CheckResult, type NamedCheckResult, } from './tier-validator.js';
+export { logProgress, logComplete, logFailed, logError, logInfo, logLoading, logSearching, } from './progress-indicator.js';
+export { debug, info, warn, error, DebugLogger } from './debug-logger.js';
+export { formatTimeAgo } from './time-formatter.js';
+export { MAMAError, NotFoundError, ValidationError, DatabaseError, EmbeddingError, ConfigurationError, LinkError, RateLimitError, TimeoutError, ErrorCodes, wrapError, isMAMAError, type ErrorDetails, type ErrorResponse, type ErrorJSON, type ErrorCode, } from './errors.js';
+export { formatContext, formatLegacyContext, formatRecall, formatList, formatTeaser, formatInstantAnswer, formatTrustContext, ensureTokenBudget, estimateTokens, extractQuickAnswer, extractCodeExample, type DecisionForFormat, type TrustContext, type SemanticEdges as FormatterSemanticEdges, type FormatOptions, } from './decision-formatter.js';
+export { analyzeOutcome, matchesFailureIndicators, matchesSuccessIndicators, matchesPartialIndicators, extractFailureReason, getRecentDecision, calculateDurationDays, getEvidenceImpact, markOutcome, onUserPromptSubmit, FAILURE_INDICATORS, SUCCESS_INDICATORS, PARTIAL_INDICATORS, RECENT_WINDOW_MS, type HookContext, type OutcomeType, } from './outcome-tracker.js';
+export { injectDecisionContext } from './memory-inject.js';
+export { analyzeIntent, extractTopicKeywords, type IntentResult, type AnalyzeOptions, } from './query-intent.js';
+export { generate, analyzeDecision, analyzeQueryIntent, isAvailable, listModels, DEFAULT_MODEL, FALLBACK_MODEL, type GenerateOptions, type DecisionAnalysisResult, type QueryIntentResult, } from './ollama-client.js';
+export { notifyInsight } from './notification-manager.js';
+//# sourceMappingURL=index.d.ts.map