memorylink 1.0.0

package/dist/utils.js

@@ -0,0 +1,822 @@
+"use strict";
+/**
+ * MemoryLink - Utility Functions
+ *
+ * v1.0 UPDATE: Added JSONL utilities, file locking, secret detection,
+ * and duration parsing for robust, concurrent-safe operations.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.colorize = colorize;
+exports.findRoot = findRoot;
+exports.getMemoryLinkDir = getMemoryLinkDir;
+exports.getFilePath = getFilePath;
+exports.normalizePath = normalizePath;
+exports.normalizePathForStorage = normalizePathForStorage;
+exports.denormalizePath = denormalizePath;
+exports.isInitialized = isInitialized;
+exports.getTimestamp = getTimestamp;
+exports.validateScope = validateScope;
+exports.formatTimestamp = formatTimestamp;
+exports.readFileSafe = readFileSafe;
+exports.appendToFile = appendToFile;
+exports.readLines = readLines;
+exports.countLines = countLines;
+exports.readConfig = readConfig;
+exports.writeConfig = writeConfig;
+exports.readIgnorePatterns = readIgnorePatterns;
+exports.log = log;
+exports.success = success;
+exports.error = error;
+exports.warn = warn;
+exports.safeLog = safeLog;
+exports.safeError = safeError;
+exports.isStdoutWritable = isStdoutWritable;
+exports.info = info;
+exports.normalizeTag = normalizeTag;
+exports.parseTags = parseTags;
+exports.formatTags = formatTags;
+exports.ensureDir = ensureDir;
+exports.writeFileAtomic = writeFileAtomic;
+exports.relativePath = relativePath;
+exports.generateId = generateId;
+exports.shortId = shortId;
+exports.appendJsonlEntry = appendJsonlEntry;
+exports.readJsonlEntries = readJsonlEntries;
+exports.readJsonlEntriesStreaming = readJsonlEntriesStreaming;
+exports.isJsonlFormat = isJsonlFormat;
+exports.detectSecrets = detectSecrets;
+exports.checkSecretsBeforeWrite = checkSecretsBeforeWrite;
+exports.parseDuration = parseDuration;
+exports.formatDuration = formatDuration;
+exports.filterByTag = filterByTag;
+exports.filterBySince = filterBySince;
+exports.filterByStatus = filterByStatus;
+exports.searchEntries = searchEntries;
+exports.hasLegacyFormat = hasLegacyFormat;
+exports.parseLegacyMemoryLine = parseLegacyMemoryLine;
+exports.parseLegacyLearningLine = parseLegacyLearningLine;
+exports.parseLegacyChangeLine = parseLegacyChangeLine;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+const proper_lockfile_1 = __importDefault(require("proper-lockfile"));
+const types_js_1 = require("./types.js");
+// ANSI color codes (for environments where chalk might not work)
+exports.colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m',
+};
+function colorize(text, color) {
+    return `${exports.colors[color]}${text}${exports.colors.reset}`;
+}
+// Find the root directory containing .memorylink
+function findRoot(startDir = process.cwd()) {
+    let currentDir = startDir;
+    while (currentDir !== path.parse(currentDir).root) {
+        if (fs.existsSync(path.join(currentDir, types_js_1.MEMORYLINK_DIR))) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+// Get the .memorylink directory path
+function getMemoryLinkDir(root) {
+    const rootDir = root || findRoot() || process.cwd();
+    return path.join(rootDir, types_js_1.MEMORYLINK_DIR);
+}
+// Get a specific file path
+function getFilePath(file, root) {
+    return path.join(getMemoryLinkDir(root), types_js_1.FILES[file]);
+}
+/**
+ * Normalize path to use forward slashes (Git-compatible)
+ * Windows backslashes are converted to forward slashes
+ * This ensures paths are consistent across platforms for storage
+ */
+function normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/');
+}
+/**
+ * Normalize path for storage (always forward slashes, relative to root)
+ * For file operations, use platform-specific paths
+ * For storage in JSONL, use normalized forward-slash paths
+ */
+function normalizePathForStorage(filePath, root) {
+    // Normalize to forward slashes
+    let normalized = normalizePath(filePath);
+    // If absolute path, make relative to root
+    if (path.isAbsolute(normalized)) {
+        normalized = path.relative(root, normalized);
+        // Normalize again after making relative
+        normalized = normalizePath(normalized);
+    }
+    // Remove leading ./ if present
+    normalized = normalized.replace(/^\.\//, '');
+    return normalized;
+}
+/**
+ * Convert normalized path to platform-specific path for file operations
+ */
+function denormalizePath(normalizedPath, root) {
+    const fullPath = path.isAbsolute(normalizedPath)
+        ? normalizedPath
+        : path.join(root, normalizedPath);
+    return path.normalize(fullPath);
+}
+// Check if MemoryLink is initialized
+function isInitialized(root) {
+    const dir = getMemoryLinkDir(root);
+    return fs.existsSync(dir) && fs.existsSync(path.join(dir, types_js_1.FILES.CONFIG));
+}
+// Get current timestamp in ISO format
+function getTimestamp() {
+    return new Date().toISOString();
+}
+/**
+ * Validate project scope name (v1.5 Phase 2)
+ * Rules: max 50 chars, alphanumeric, dash, underscore
+ */
+function validateScope(scope) {
+    if (!scope || scope.trim().length === 0) {
+        return { valid: false, error: 'Scope cannot be empty' };
+    }
+    if (scope.length > 50) {
+        return { valid: false, error: 'Scope must be 50 characters or less' };
+    }
+    // Allow: alphanumeric, dash, underscore, forward slash (for hierarchical)
+    const validPattern = /^[a-zA-Z0-9_/-]+$/;
+    if (!validPattern.test(scope)) {
+        return { valid: false, error: 'Scope can only contain letters, numbers, dashes, underscores, and slashes' };
+    }
+    return { valid: true };
+}
+// Format timestamp for display
+function formatTimestamp(iso) {
+    const date = new Date(iso);
+    return date.toLocaleString();
+}
+// Read a file safely
+function readFileSafe(filePath) {
+    try {
+        return fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+// Append to a file
+function appendToFile(filePath, content) {
+    fs.appendFileSync(filePath, content + '\n');
+}
+// Read lines from a file (non-empty)
+function readLines(filePath) {
+    const content = readFileSafe(filePath);
+    return content.split('\n').filter(line => line.trim() !== '');
+}
+// Count lines in a file
+function countLines(filePath) {
+    return readLines(filePath).length;
+}
+// Read the config file
+function readConfig(root) {
+    const configPath = getFilePath('CONFIG', root);
+    try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+// Write the config file
+function writeConfig(config, root) {
+    const configPath = getFilePath('CONFIG', root);
+    writeFileAtomic(configPath, JSON.stringify(config, null, 2));
+}
+// Read ignore patterns
+function readIgnorePatterns(root) {
+    const ignorePath = path.join(root || findRoot() || process.cwd(), types_js_1.FILES.IGNORE);
+    if (fs.existsSync(ignorePath)) {
+        const content = fs.readFileSync(ignorePath, 'utf-8');
+        const patterns = content.split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+        return [...types_js_1.DEFAULT_IGNORE_PATTERNS, ...patterns];
+    }
+    return types_js_1.DEFAULT_IGNORE_PATTERNS;
+}
+// Log with optional verbose mode
+function log(message, verbose = false) {
+    if (verbose) {
+        console.log(colorize(`[DEBUG] ${getTimestamp()}`, 'gray'), message);
+    }
+}
+// Print success message
+function success(message) {
+    console.log(colorize('✓', 'green'), message);
+}
+// Print error message
+function error(message) {
+    console.error(colorize('✗', 'red'), message);
+    // Reference troubleshooting guide for common errors
+    if (message.includes('not initialized') ||
+        message.includes('Failed to read') ||
+        message.includes('locked') ||
+        message.includes('parse error')) {
+        console.error(colorize('💡', 'cyan'), 'Run `memorylink doctor` for diagnosis, or see TROUBLESHOOTING.md');
+    }
+}
+// Print warning message
+function warn(message) {
+    console.log(colorize('⚠', 'yellow'), message);
+}
+/**
+ * Safe console.log that handles EPIPE errors gracefully
+ * Used when output might be piped to /dev/null or closed streams
+ */
+function safeLog(...args) {
+    try {
+        console.log(...args);
+    }
+    catch (err) {
+        // Ignore EPIPE errors (broken pipe) - happens when stdout is closed
+        if (err.code !== 'EPIPE' && err.errno !== -32) {
+            // Re-throw if it's not an EPIPE error
+            throw err;
+        }
+        // Silently ignore EPIPE - this is expected when output is suppressed
+    }
+}
+/**
+ * Safe console.error that handles EPIPE errors gracefully
+ */
+function safeError(...args) {
+    try {
+        console.error(...args);
+    }
+    catch (err) {
+        // Ignore EPIPE errors (broken pipe)
+        if (err.code !== 'EPIPE' && err.errno !== -32) {
+            throw err;
+        }
+    }
+}
+/**
+ * Check if stdout is writable before writing
+ * Returns true if safe to write, false otherwise
+ */
+function isStdoutWritable() {
+    try {
+        return process.stdout.writable && !process.stdout.destroyed;
+    }
+    catch {
+        return false;
+    }
+}
+// Print info message
+function info(message) {
+    console.log(colorize('ℹ', 'blue'), message);
+}
+/**
+ * Normalize a single tag (lowercase, hyphenate spaces)
+ * Examples: "TypeScript" → "typescript", "Type Script" → "type-script"
+ */
+function normalizeTag(tag) {
+    return tag
+        .toLowerCase() // "TypeScript" → "typescript"
+        .trim() // Remove whitespace
+        .replace(/\s+/g, '-') // "Type Script" → "type-script"
+        .replace(/[^a-z0-9-]/g, '') // Remove special chars (keep alphanumeric and hyphens)
+        .replace(/-+/g, '-') // Multiple hyphens → single hyphen
+        .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
+}
+/**
+ * Parse and normalize tags from comma-separated string
+ * Tags are automatically normalized (lowercase, hyphenated)
+ */
+function parseTags(tagString) {
+    if (!tagString)
+        return [];
+    return tagString
+        .split(',')
+        .map(t => normalizeTag(t))
+        .filter(t => t.length > 0); // Filter out empty tags after normalization
+}
+// Format tags for storage
+function formatTags(tags) {
+    return tags.length > 0 ? ` [${tags.join(', ')}]` : '';
+}
+// Ensure directory exists
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+// Atomic write helper (write temp then rename)
+function writeFileAtomic(filePath, content) {
+    const dir = path.dirname(filePath);
+    ensureDir(dir);
+    const tempPath = path.join(dir, `.tmp-${path.basename(filePath)}-${Date.now()}`);
+    fs.writeFileSync(tempPath, content);
+    fs.renameSync(tempPath, filePath);
+}
+// Relative path from root
+function relativePath(fullPath, root) {
+    const rootDir = root || findRoot() || process.cwd();
+    return path.relative(rootDir, fullPath);
+}
+// ============================================
+// UUID GENERATION
+// ============================================
+/**
+ * Generate a unique ID for log entries
+ */
+function generateId() {
+    return (0, uuid_1.v4)();
+}
+/**
+ * Generate a short ID prefix for display (first 8 chars)
+ */
+function shortId(id) {
+    return id.substring(0, 8);
+}
+// ============================================
+// FILE LOCKING (Concurrent Write Protection)
+// ============================================
+/**
+ * Append a JSONL entry to a log file with file locking
+ * Prevents concurrent write corruption
+ */
+async function appendJsonlEntry(filePath, entry) {
+    // Ensure file exists
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '');
+    }
+    // Acquire lock with retries
+    let release = null;
+    try {
+        release = await proper_lockfile_1.default.lock(filePath, {
+            retries: {
+                retries: 5,
+                minTimeout: 100,
+                maxTimeout: 1000,
+            },
+        });
+        // Append JSONL entry
+        const line = JSON.stringify(entry) + '\n';
+        // Guard against oversized entries
+        if (line.length > 10000) {
+            throw new Error('Entry too large to store. Please shorten the message.');
+        }
+        fs.appendFileSync(filePath, line);
+    }
+    finally {
+        // Release lock
+        if (release) {
+            await release();
+        }
+    }
+}
+/**
+ * Normalize v1.3 MemoryEntry to v1.4 format with defaults
+ * Maintains backward compatibility while adding v1.4 fields
+ */
+function normalizeMemoryEntryToV14(entry, root) {
+    // If already v1.4, return as-is
+    if (entry.schemaVersion === '1.4.0') {
+        return entry;
+    }
+    // Determine source type from agent field
+    const sourceType = entry.agent === 'user' || !entry.agent || entry.agent === 'migrated'
+        ? 'human'
+        : ['cursor', 'claude', 'chatgpt', 'copilot', 'windsurf'].includes(entry.agent.toLowerCase())
+            ? 'agent'
+            : 'code';
+    // Determine memory status: VERIFIED for human, DRAFT for agent
+    const memoryStatus = sourceType === 'human' ? 'VERIFIED' : 'DRAFT';
+    // Build provenance from existing fields
+    const provenance = {
+        createdAt: entry.ts,
+        createdBy: entry.agent || 'unknown',
+        tool: entry.agent || undefined,
+        kind: sourceType === 'human' ? 'user' : 'app',
+    };
+    // Get project path (relative to root)
+    const projectPath = root || process.cwd();
+    // Add v1.4 fields with defaults
+    return {
+        ...entry,
+        schemaVersion: '1.4.0',
+        recordVersion: 1,
+        projectPath,
+        sensitivity: 'internal',
+        trustLevel: 'medium',
+        memoryStatus,
+        sourceType,
+        provenance,
+    };
+}
+/**
+ * Detect schema version from an entry
+ */
+function detectSchemaVersion(entry) {
+    if (entry.schemaVersion) {
+        return entry.schemaVersion;
+    }
+    // v1.3 and earlier don't have schemaVersion
+    return '1.3.0';
+}
+/**
+ * Read all JSONL entries from a log file
+ * v1.4: Automatically normalizes v1.3 entries to v1.4 format
+ */
+function readJsonlEntries(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim() !== '');
+    const entries = [];
+    const root = findRoot() || process.cwd();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        // Skip comments (legacy format)
+        if (line.startsWith('#')) {
+            continue;
+        }
+        try {
+            const entry = JSON.parse(line);
+            // Normalize MemoryEntry from v1.3 to v1.4 if needed
+            if (filePath.includes('memory.log') && typeof entry === 'object' && entry !== null && 'type' in entry && 'details' in entry) {
+                const memEntry = entry;
+                const schemaVersion = detectSchemaVersion(memEntry);
+                if (schemaVersion < '1.4.0') {
+                    const normalized = normalizeMemoryEntryToV14(memEntry, root);
+                    entries.push(normalized);
+                    continue;
+                }
+            }
+            entries.push(entry);
+        }
+        catch (err) {
+            // Skip invalid JSON lines (might be legacy format)
+            warn(`Line ${i + 1}: Invalid JSON, skipping`);
+        }
+    }
+    return entries;
+}
+/**
+ * Read JSONL entries with streaming (memory-efficient for large files)
+ * Use this for files with 10K+ entries
+ */
+async function readJsonlEntriesStreaming(filePath, options = {}) {
+    const { streamJsonlEntries } = await import('./utils/streaming.js');
+    const entries = [];
+    for await (const entry of streamJsonlEntries(filePath, options)) {
+        entries.push(entry);
+    }
+    return entries;
+}
+/**
+ * Check if a log file is in JSONL format
+ */
+function isJsonlFormat(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return true; // New files will be JSONL
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(line => line.trim() !== '' && !line.startsWith('#'));
+    if (lines.length === 0) {
+        return true; // Empty file
+    }
+    // Check first non-comment line
+    const firstLine = lines[0].trim();
+    return firstLine.startsWith('{');
+}
+/**
+ * Check content for potential secrets
+ */
+function detectSecrets(content) {
+    const detectedPatterns = [];
+    for (const secretPattern of types_js_1.SECRET_PATTERNS) {
+        if (secretPattern.pattern.test(content)) {
+            detectedPatterns.push(secretPattern.name);
+        }
+    }
+    return {
+        detected: detectedPatterns.length > 0,
+        patterns: detectedPatterns,
+    };
+}
+/**
+ * Check for prompt injection patterns (system prompts, instruction overrides)
+ */
+function detectPromptInjection(content) {
+    const promptInjectionPatterns = [
+        /ignore\s+(previous|all|above)\s+(instructions|rules|context)/i,
+        /forget\s+(everything|all|previous)/i,
+        /you\s+are\s+now\s+(a|an)\s+/i,
+        /system\s*:\s*(you|ignore|forget)/i,
+        /\[SYSTEM\]|\[INST\]|\[PROMPT\]/i,
+        /override\s+(previous|all|system)\s+(instructions|rules)/i,
+        /new\s+(instructions|rules|system)\s*:/i,
+        /disregard\s+(previous|all|above)/i,
+    ];
+    return promptInjectionPatterns.some(pattern => pattern.test(content));
+}
+/**
+ * Check content for secrets and prompt injection, handle based on force flag
+ * Returns true if write should proceed, false if blocked
+ */
+function checkSecretsBeforeWrite(content, force = false) {
+    // Check for prompt injection first
+    if (detectPromptInjection(content) && !force) {
+        console.error('');
+        console.error(colorize('❌ PROMPT INJECTION DETECTED - Command blocked', 'red'));
+        console.error('');
+        console.error('Detected suspicious patterns that could override AI behavior.');
+        console.error('');
+        console.error(colorize('Why this is dangerous:', 'yellow'));
+        console.error('  1. Could inject malicious instructions into AI context');
+        console.error('  2. Could override safety rules and preferences');
+        console.error('  3. Could compromise AI behavior in team environments');
+        console.error('');
+        console.error(colorize('Recommended actions:', 'cyan'));
+        console.error('  1. Rephrase without instruction-override language');
+        console.error('  2. Use clear, declarative statements instead');
+        console.error('     Example: "Project uses TypeScript" (not "Forget previous, use TypeScript")');
+        console.error('');
+        console.error(colorize('If you\'re CERTAIN this is safe:', 'yellow'));
+        console.error('  Add --force flag to proceed');
+        console.error('');
+        return false; // Block write
+    }
+    const result = detectSecrets(content);
+    if (!result.detected) {
+        return true; // No secrets, proceed
+    }
+    if (!force) {
+        // Block write and show warning
+        console.error('');
+        console.error(colorize('❌ SECRET DETECTED - Command blocked', 'red'));
+        console.error('');
+        console.error('Detected patterns:');
+        for (const pattern of result.patterns) {
+            console.error(`  - ${pattern}`);
+        }
+        console.error('');
+        console.error(colorize('Why this is dangerous:', 'yellow'));
+        console.error('  1. Secrets will be committed to Git');
+        console.error('  2. Secrets will be in Git history forever');
+        console.error('  3. Team members will see secrets');
+        console.error('  4. Secrets may be pushed to remote repos');
+        console.error('');
+        console.error(colorize('Recommended actions:', 'cyan'));
+        console.error('  1. Use environment variables instead');
+        console.error('  2. Reference secrets, don\'t include them');
+        console.error('     Example: "API key stored in .env file"');
+        console.error('');
+        console.error(colorize('If you\'re CERTAIN this is not a secret:', 'yellow'));
+        console.error('  Add --force flag to proceed');
+        console.error('');
+        return false; // Block write
+    }
+    // Force flag used - warn but allow
+    console.warn('');
+    console.warn(colorize('⚠️  WARNING: Secret pattern detected but proceeding (--force)', 'yellow'));
+    console.warn('You are responsible for this secret in version control.');
+    console.warn('');
+    return true; // Allow write with warning
+}
+// ============================================
+// DURATION PARSING
+// ============================================
+/**
+ * Parse a duration string like "7d", "2w", "1m" to a Date
+ * Returns date that is `duration` ago from now
+ */
+function parseDuration(duration) {
+    const match = duration.match(/^(\d+)([dwmy])$/);
+    if (!match) {
+        return null;
+    }
+    const [, numStr, unit] = match;
+    const num = parseInt(numStr, 10);
+    const ms = types_js_1.DURATION_MS[unit];
+    if (!ms) {
+        return null;
+    }
+    return new Date(Date.now() - num * ms);
+}
+/**
+ * Format a duration for display
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ago`;
+    if (hours > 0)
+        return `${hours}h ago`;
+    if (minutes > 0)
+        return `${minutes}m ago`;
+    return `${seconds}s ago`;
+}
+// ============================================
+// ENTRY FILTERING
+// ============================================
+/**
+ * Filter entries by tag
+ */
+function filterByTag(entries, tag) {
+    const lowerTag = tag.toLowerCase();
+    return entries.filter(e => e.tags?.some(t => t.toLowerCase() === lowerTag));
+}
+/**
+ * Filter entries by date (since duration)
+ */
+function filterBySince(entries, since) {
+    const cutoff = parseDuration(since);
+    if (!cutoff)
+        return entries;
+    return entries.filter(e => new Date(e.ts) > cutoff);
+}
+/**
+ * Filter entries by status
+ */
+function filterByStatus(entries, status) {
+    return entries.filter(e => e.status === status);
+}
+/**
+ * Search entries by keyword (in details, problem, solution, or tags)
+ */
+function searchEntries(entries, keyword) {
+    const kw = keyword.toLowerCase();
+    return entries.filter(e => {
+        // Check tags
+        if (e.tags?.some(t => t.toLowerCase().includes(kw))) {
+            return true;
+        }
+        // Check memory-specific fields
+        const memEntry = e;
+        if (memEntry.details?.toLowerCase().includes(kw)) {
+            return true;
+        }
+        // Check learning-specific fields
+        const learnEntry = e;
+        if (learnEntry.problem?.toLowerCase().includes(kw)) {
+            return true;
+        }
+        if (learnEntry.solution?.toLowerCase().includes(kw)) {
+            return true;
+        }
+        // Check change-specific fields
+        const changeEntry = e;
+        if (changeEntry.file?.toLowerCase().includes(kw)) {
+            return true;
+        }
+        if (changeEntry.reason?.toLowerCase().includes(kw)) {
+            return true;
+        }
+        // Check code snippet-specific fields
+        if (memEntry.type === 'code_snippet') {
+            if (memEntry.code?.toLowerCase().includes(kw)) {
+                return true;
+            }
+            if (memEntry.language?.toLowerCase().includes(kw)) {
+                return true;
+            }
+            if (memEntry.context?.toLowerCase().includes(kw)) {
+                return true;
+            }
+        }
+        return false;
+    });
+}
+// ============================================
+// LEGACY FORMAT DETECTION & PARSING
+// ============================================
+/**
+ * Check if any log files are in legacy (text) format
+ */
+function hasLegacyFormat(root) {
+    const logFiles = ['MEMORY', 'LEARNINGS', 'CHANGES'];
+    for (const fileKey of logFiles) {
+        const filePath = getFilePath(fileKey, root);
+        if (fs.existsSync(filePath) && !isJsonlFormat(filePath)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Parse legacy memory entry: [TIMESTAMP] MESSAGE [tags]
+ */
+function parseLegacyMemoryLine(line) {
+    const match = line.match(/\[(.*?)\]\s*(.+?)(\s*\[.*\])?$/);
+    if (!match)
+        return null;
+    const [, timestamp, message, tagsStr] = match;
+    const tags = tagsStr
+        ? tagsStr.slice(2, -1).split(',').map(t => t.trim()).filter(Boolean)
+        : [];
+    return {
+        id: generateId(),
+        ts: timestamp,
+        agent: 'migrated',
+        type: 'note',
+        details: message.trim(),
+        tags,
+        status: 'ACTIVE',
+    };
+}
+/**
+ * Parse legacy learning entry: [TIMESTAMP] [STATUS] PROBLEM -> SOLUTION [tags]
+ */
+function parseLegacyLearningLine(line) {
+    const match = line.match(/\[(.*?)\]\s*\[(.*?)\]\s*(.+?)\s*->\s*(.+?)(\s*\[.*\])?$/);
+    if (!match)
+        return null;
+    const [, timestamp, statusPart, problem, solution, tagsStr] = match;
+    const outcome = statusPart.includes('SUCCESS') ? 'SUCCESS' : 'FAILED';
+    const tags = tagsStr
+        ? tagsStr.slice(2, -1).split(',').map(t => t.trim()).filter(Boolean)
+        : [];
+    return {
+        id: generateId(),
+        ts: timestamp,
+        agent: 'migrated',
+        problem: problem.trim(),
+        solution: solution.trim(),
+        outcome,
+        tags,
+        status: 'ACTIVE',
+    };
+}
+/**
+ * Parse legacy change entry: [TIMESTAMP] FILE: REASON (agent)
+ */
+function parseLegacyChangeLine(line) {
+    const match = line.match(/\[(.*?)\]\s*(.+?):\s*(.+?)(\s*\(.*\))?$/);
+    if (!match)
+        return null;
+    const [, timestamp, file, reason, agentStr] = match;
+    const agent = agentStr ? agentStr.slice(2, -1) : 'migrated';
+    return {
+        id: generateId(),
+        ts: timestamp,
+        agent,
+        file: file.trim(),
+        action: 'edited',
+        reason: reason.trim(),
+        status: 'ACTIVE',
+    };
+}
+//# sourceMappingURL=utils.js.map