@jungjaehoon/mama-core 1.1.2 → 1.1.3

package/dist/tier-validator.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * MAMA Tier Validator
+ *
+ * Centralized tier validation module for MAMA.
+ * Validates system requirements and determines tier status (1 or 2).
+ *
+ * Tier 1: Full features (Node.js 18+, SQLite, Embeddings, Database)
+ * Tier 2: Degraded mode (missing one or more requirements)
+ *
+ * @module tier-validator
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNodeVersion = checkNodeVersion;
+exports.checkSQLite = checkSQLite;
+exports.checkEmbeddings = checkEmbeddings;
+exports.checkDatabase = checkDatabase;
+exports.validateTier = validateTier;
+exports.getTierDescription = getTierDescription;
+exports.getTierBanner = getTierBanner;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Validates Node.js version requirement
+ */
+function checkNodeVersion() {
+    try {
+        const nodeVersion = process.versions.node;
+        const majorVersion = parseInt(nodeVersion.split('.')[0], 10);
+        if (majorVersion >= 18) {
+            return {
+                status: 'pass',
+                details: `v${nodeVersion}`,
+            };
+        }
+        return {
+            status: 'fail',
+            details: `v${nodeVersion} (requires 18+)`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'fail',
+            details: `Error checking version: ${message}`,
+        };
+    }
+}
+/**
+ * Validates SQLite (better-sqlite3) availability
+ */
+function checkSQLite() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const Database = require('better-sqlite3');
+        // Test instantiation with in-memory database
+        const testDb = new Database(':memory:');
+        testDb.close();
+        return {
+            status: 'pass',
+            details: 'better-sqlite3 native module ready',
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'fail',
+            details: `better-sqlite3 not available: ${message}`,
+        };
+    }
+}
+/**
+ * Validates embedding model availability
+ */
+function checkEmbeddings() {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { getModelName } = require('./embeddings');
+        const modelName = getModelName();
+        // Check if model is cached
+        const cacheDir = process.env.HF_HOME ||
+            process.env.TRANSFORMERS_CACHE ||
+            path_1.default.join(os_1.default.homedir(), '.cache', 'huggingface', 'transformers');
+        // Model cache structure: cache_dir/models--org--model/snapshots/hash/
+        const modelPath = path_1.default.join(cacheDir, `models--${modelName.replace('/', '--')}`);
+        if (fs_1.default.existsSync(modelPath)) {
+            return {
+                status: 'pass',
+                details: `${modelName} (cached)`,
+            };
+        }
+        return {
+            status: 'fail',
+            details: `${modelName} not cached (will download on first use)`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'fail',
+            details: `Error checking embeddings: ${message}`,
+        };
+    }
+}
+/**
+ * Validates database file accessibility
+ */
+function checkDatabase() {
+    try {
+        const dbPath = process.env.MAMA_DB_PATH || path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
+        const dbDir = path_1.default.dirname(dbPath);
+        // Check if directory exists or can be created
+        if (!fs_1.default.existsSync(dbDir)) {
+            try {
+                fs_1.default.mkdirSync(dbDir, { recursive: true });
+            }
+            catch (mkdirErr) {
+                const message = mkdirErr instanceof Error ? mkdirErr.message : String(mkdirErr);
+                return {
+                    status: 'fail',
+                    details: `Cannot create database directory: ${message}`,
+                };
+            }
+        }
+        // Check write access
+        try {
+            fs_1.default.accessSync(dbDir, fs_1.default.constants.W_OK);
+        }
+        catch {
+            return {
+                status: 'fail',
+                details: `No write access to ${dbDir}`,
+            };
+        }
+        return {
+            status: 'pass',
+            details: dbPath,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'fail',
+            details: `Error checking database: ${message}`,
+        };
+    }
+}
+/**
+ * Validates MAMA tier status
+ *
+ * Performs all system checks and determines tier:
+ * - Tier 1: All checks pass (full features)
+ * - Tier 2: One or more checks fail (degraded mode)
+ */
+async function validateTier() {
+    const checks = [
+        {
+            name: 'Node.js',
+            ...checkNodeVersion(),
+        },
+        {
+            name: 'SQLite',
+            ...checkSQLite(),
+        },
+        {
+            name: 'Embeddings',
+            ...checkEmbeddings(),
+        },
+        {
+            name: 'Database',
+            ...checkDatabase(),
+        },
+    ];
+    // Determine tier: all pass = tier 1, any fail = tier 2
+    const tier = checks.every((c) => c.status === 'pass') ? 1 : 2;
+    return {
+        tier,
+        checks,
+    };
+}
+/**
+ * Get user-friendly tier description
+ */
+function getTierDescription(tier) {
+    const descriptions = {
+        1: 'Full Features - All systems operational',
+        2: 'Degraded Mode - Some features unavailable',
+    };
+    return descriptions[tier] || 'Unknown Tier';
+}
+/**
+ * Get tier status banner
+ */
+function getTierBanner(validation) {
+    const { tier, checks } = validation;
+    const failedChecks = checks.filter((c) => c.status === 'fail');
+    let banner = `\n┌─────────────────────────────────────────┐\n`;
+    banner += `│ MAMA Tier ${tier}: ${getTierDescription(tier).split(' - ')[0]}\n`;
+    if (failedChecks.length > 0) {
+        banner += `│\n`;
+        banner += `│ ⚠️  Issues detected:\n`;
+        failedChecks.forEach((check) => {
+            banner += `│ • ${check.name}: ${check.details}\n`;
+        });
+    }
+    else {
+        banner += `│ ✅ All systems operational\n`;
+    }
+    banner += `└─────────────────────────────────────────┘\n`;
+    return banner;
+}
+//# sourceMappingURL=tier-validator.js.map

package/dist/time-formatter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Time Formatter - Human-Readable Time Formatting
+ *
+ * Converts Unix timestamps to human-readable relative time format
+ * Examples: "2d ago", "3h ago", "just now"
+ *
+ * Used by list_decisions and recall_decision tools
+ *
+ * @module time-formatter
+ */
+/**
+ * Format Unix timestamp (milliseconds) to human-readable relative time
+ *
+ * AC #2: Format created_at as human-readable ("2d ago", "3h ago", etc.)
+ *
+ * @param timestamp - Unix timestamp in milliseconds OR ISO 8601 string
+ * @returns Human-readable time string
+ *
+ * @example
+ * formatTimeAgo(Date.now() - 3600000) // "1h ago"
+ * formatTimeAgo(Date.now() - 172800000) // "2d ago"
+ * formatTimeAgo("2025-11-20T10:30:00Z") // "2d ago" (if today is 2025-11-22)
+ */
+export declare function formatTimeAgo(timestamp: number | string | null | undefined): string;
+//# sourceMappingURL=time-formatter.d.ts.map

package/dist/time-formatter.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Time Formatter - Human-Readable Time Formatting
+ *
+ * Converts Unix timestamps to human-readable relative time format
+ * Examples: "2d ago", "3h ago", "just now"
+ *
+ * Used by list_decisions and recall_decision tools
+ *
+ * @module time-formatter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTimeAgo = formatTimeAgo;
+const debug_logger_js_1 = require("./debug-logger.js");
+/**
+ * Format Unix timestamp (milliseconds) to human-readable relative time
+ *
+ * AC #2: Format created_at as human-readable ("2d ago", "3h ago", etc.)
+ *
+ * @param timestamp - Unix timestamp in milliseconds OR ISO 8601 string
+ * @returns Human-readable time string
+ *
+ * @example
+ * formatTimeAgo(Date.now() - 3600000) // "1h ago"
+ * formatTimeAgo(Date.now() - 172800000) // "2d ago"
+ * formatTimeAgo("2025-11-20T10:30:00Z") // "2d ago" (if today is 2025-11-22)
+ */
+function formatTimeAgo(timestamp) {
+    try {
+        // Handle null/undefined (but allow 0 as valid Unix epoch)
+        if (timestamp === null || timestamp === undefined) {
+            (0, debug_logger_js_1.warn)('[time-formatter] Timestamp is null or undefined, returning "unknown"');
+            return 'unknown';
+        }
+        // Parse ISO 8601 string to timestamp (if string provided)
+        let timestampMs;
+        if (typeof timestamp === 'string') {
+            timestampMs = new Date(timestamp).getTime();
+            if (isNaN(timestampMs)) {
+                (0, debug_logger_js_1.warn)(`[time-formatter] Invalid ISO 8601 string: ${timestamp}`);
+                return 'unknown';
+            }
+        }
+        else {
+            timestampMs = timestamp;
+        }
+        const now = Date.now();
+        const diff = now - timestampMs;
+        // Handle future timestamps (shouldn't happen, but be defensive)
+        if (diff < 0) {
+            (0, debug_logger_js_1.warn)(`[time-formatter] Future timestamp detected: ${timestamp}`);
+            return 'just now';
+        }
+        // Calculate time units
+        const seconds = Math.floor(diff / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        const weeks = Math.floor(days / 7);
+        const months = Math.floor(days / 30);
+        const years = Math.floor(days / 365);
+        // Return human-readable format
+        if (seconds < 60) {
+            return 'just now';
+        }
+        if (minutes < 60) {
+            return `${minutes}m ago`;
+        }
+        if (hours < 24) {
+            return `${hours}h ago`;
+        }
+        if (days < 7) {
+            return `${days}d ago`;
+        }
+        if (weeks < 4) {
+            return `${weeks}w ago`;
+        }
+        // Guard against "0mo ago" when days are 28-29 (months = Math.floor(days/30) = 0)
+        if (months < 1) {
+            return `${weeks}w ago`;
+        }
+        if (months < 12) {
+            return `${months}mo ago`;
+        }
+        return `${years}y ago`;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, debug_logger_js_1.warn)(`[time-formatter] Error formatting timestamp ${timestamp}: ${message}`);
+        return 'unknown';
+    }
+}
+//# sourceMappingURL=time-formatter.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-core",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "MAMA Core - Shared modules for Memory-Augmented MCP Assistant",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,8 @@
     "./errors": "./dist/errors.js",
     "./time-formatter": "./dist/time-formatter.js",
     "./outcome-tracker": "./dist/outcome-tracker.js",
-    "./query-intent": "./dist/query-intent.js"
+    "./query-intent": "./dist/query-intent.js",
+    "./test-utils": "./dist/test-utils.js"
   },
   "scripts": {
     "build": "tsc",