@compr/opscontext-mcp 2.0.0

package/dist/learnings.js

@@ -0,0 +1,714 @@
+// LOCKED — verified March 3 2026 — learning store: quality gates, auto-categorize, dedup, project-scoped filtering
+// DO NOT RE-AUDIT — min 15 chars, inferCategory(), autoImportFromSources() all verified v1.19.1
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { safeAppend } from "./audit.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Learning Store — permanent operational rules that persist forever.
+ *
+ * Unlike sessions (ephemeral per-conversation context), learnings are
+ * **permanent rules** discovered during coding sessions. They get
+ * auto-indexed and surfaced via search_context so AI agents don't
+ * repeat the same mistakes.
+ *
+ * Storage: ~/.contextengine/learnings.json
+ *
+ * Examples:
+ * - "Always restart Flask backend after model changes — stale to_dict()"
+ * - "Expo --port flag only controls Metro, NOT webpack dev server"
+ * - "macOS sandbox blocks ~/Downloads access from VS Code terminal"
+ * - "Unicode NFC vs NFD causes false mismatches on Google Drive vs APFS"
+ */
+const LEARNINGS_PATH = join(homedir(), ".contextengine", "learnings.json");
+/** Valid categories for learnings */
+export const LEARNING_CATEGORIES = [
+    "deployment",
+    "api",
+    "database",
+    "frontend",
+    "backend",
+    "devops",
+    "security",
+    "performance",
+    "testing",
+    "debugging",
+    "tooling",
+    "git",
+    "dependencies",
+    "architecture",
+    "data",
+    "infrastructure",
+    "mobile",
+    "other",
+];
+function ensureDir() {
+    const dir = join(homedir(), ".contextengine");
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * Load bundled starter learnings from the npm package's defaults/ directory.
+ * These are curated, universal best practices shipped with every install.
+ */
+function loadBundledDefaults() {
+    // defaults/ sits next to dist/ in the package root
+    const defaultsPath = join(__dirname, "..", "defaults", "learnings.json");
+    if (existsSync(defaultsPath)) {
+        try {
+            return JSON.parse(readFileSync(defaultsPath, "utf-8"));
+        }
+        catch {
+            // Malformed defaults — skip silently
+        }
+    }
+    return [];
+}
+/**
+ * Merge bundled defaults into user store if they don't already exist.
+ * Uses rule text (lowercased) for dedup — user learnings always win.
+ */
+function mergeDefaults(store) {
+    const bundled = loadBundledDefaults();
+    if (bundled.length === 0)
+        return false;
+    const existingRules = new Set(store.learnings
+        .filter((l) => typeof l.rule === "string")
+        .map((l) => l.rule.toLowerCase().trim()));
+    let added = 0;
+    const now = new Date().toISOString();
+    for (const def of bundled) {
+        if (existingRules.has(def.rule.toLowerCase().trim()))
+            continue;
+        store.learnings.push({
+            id: generateId(),
+            category: def.category,
+            rule: def.rule,
+            context: def.context,
+            tags: def.tags || [],
+            created: now,
+            updated: now,
+        });
+        existingRules.add(def.rule.toLowerCase().trim());
+        added++;
+    }
+    return added > 0;
+}
+function loadStore() {
+    let store;
+    if (existsSync(LEARNINGS_PATH)) {
+        try {
+            store = JSON.parse(readFileSync(LEARNINGS_PATH, "utf-8"));
+            // Filter out corrupted entries missing required 'rule' field
+            store.learnings = store.learnings.filter((l) => typeof l.rule === "string" && l.rule.length > 0);
+        }
+        catch {
+            // Corrupted file — start fresh
+            store = { version: 1, count: 0, learnings: [] };
+        }
+    }
+    else {
+        store = { version: 1, count: 0, learnings: [] };
+    }
+    // Auto-merge bundled defaults on first load or when new defaults are added
+    if (mergeDefaults(store)) {
+        saveStore(store);
+    }
+    return store;
+}
+function saveStore(store) {
+    ensureDir();
+    store.count = store.learnings.length;
+    writeFileSync(LEARNINGS_PATH, JSON.stringify(store, null, 2));
+}
+/** Generate a short unique ID */
+function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).substring(2, 6);
+}
+/** Extract tags from rule + context text */
+function extractTags(rule, context, category) {
+    const text = `${rule} ${context}`.toLowerCase();
+    const tags = new Set([category]);
+    // Common tech keywords
+    const techWords = [
+        "flask", "laravel", "react", "expo", "docker", "nginx", "pm2",
+        "mysql", "postgres", "redis", "node", "python", "php", "typescript",
+        "git", "npm", "composer", "pip", "api", "cors", "jwt", "oauth",
+        "ssl", "https", "ssh", "dns", "gps", "macos", "linux", "windows",
+        "webpack", "vite", "cra", "nextjs", "flutter", "swift", "kotlin",
+        "supervisor", "cron", "smtp", "queue", "cache", "migration",
+        "unicode", "encoding", "permissions", "sandbox", "firewall",
+    ];
+    for (const word of techWords) {
+        if (text.includes(word)) {
+            tags.add(word);
+        }
+    }
+    return Array.from(tags);
+}
+/** Minimum rule length — anything shorter is noise, not knowledge */
+const MIN_RULE_LENGTH = 15;
+/**
+ * Save a new learning. Returns the created learning with ID.
+ * Rejects rules shorter than MIN_RULE_LENGTH and auto-corrects "other" category.
+ */
+export function saveLearning(category, rule, context, project) {
+    const trimmedRule = rule.trim();
+    // Quality gate: reject junk rules
+    if (trimmedRule.length < MIN_RULE_LENGTH) {
+        throw new Error(`Rule too short (${trimmedRule.length} chars, min ${MIN_RULE_LENGTH}). ` +
+            `Learnings must be actionable sentences, not single words. Example: ` +
+            `"Always restart Flask after model changes — stale to_dict() cache"`);
+    }
+    // Quality gate: auto-correct "other" category by inferring from rule + context
+    if (category === "other") {
+        const inferred = inferCategory(trimmedRule, context);
+        if (inferred !== "other") {
+            category = inferred;
+        }
+    }
+    const store = loadStore();
+    const now = new Date().toISOString();
+    // Check for duplicate rules (fuzzy: same category + similar rule text)
+    const ruleLower = rule.toLowerCase().trim();
+    const existing = store.learnings.find((l) => l.category === category &&
+        typeof l.rule === "string" && l.rule.toLowerCase().trim() === ruleLower);
+    if (existing) {
+        // Update existing learning with new context
+        existing.context = context;
+        existing.updated = now;
+        if (project)
+            existing.project = project;
+        existing.tags = extractTags(existing.rule, context, category);
+        saveStore(store);
+        safeAppend("learning.save", {
+            id: existing.id,
+            category: existing.category,
+            project: existing.project,
+            rule_length: existing.rule.length,
+            mode: "update",
+        });
+        return existing;
+    }
+    const learning = {
+        id: generateId(),
+        category: category,
+        rule,
+        context,
+        project,
+        tags: extractTags(rule, context, category),
+        created: now,
+        updated: now,
+    };
+    store.learnings.push(learning);
+    saveStore(store);
+    safeAppend("learning.save", {
+        id: learning.id,
+        category: learning.category,
+        project: learning.project,
+        rule_length: learning.rule.length,
+        mode: "create",
+    });
+    return learning;
+}
+/**
+ * Search learnings by keyword. Returns matches sorted by relevance.
+ */
+export function searchLearnings(query) {
+    const store = loadStore();
+    const tokens = query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((t) => t.length > 1);
+    if (tokens.length === 0)
+        return store.learnings;
+    const scored = [];
+    for (const learning of store.learnings) {
+        const text = `${learning.category} ${learning.rule} ${learning.context} ${learning.project || ""} ${learning.tags.join(" ")}`.toLowerCase();
+        let score = 0;
+        for (const token of tokens) {
+            if (text.includes(token)) {
+                score += 1;
+                // Bonus for matching rule text directly (the important part)
+                if (typeof learning.rule === "string" && learning.rule.toLowerCase().includes(token))
+                    score += 2;
+                // Bonus for matching category
+                if (learning.category.toLowerCase().includes(token))
+                    score += 1;
+            }
+        }
+        // Multi-term bonus
+        const distinctMatches = tokens.filter((t) => text.includes(t)).length;
+        if (distinctMatches > 1)
+            score += distinctMatches * 2;
+        if (score > 0) {
+            scored.push({ learning, score });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((s) => s.learning);
+}
+/**
+ * Get learnings, optionally filtered by category and/or project.
+ *
+ * When `projects` is provided, only returns learnings that:
+ * - match one of the given project names (case-insensitive), OR
+ * - have no project set (universal learnings)
+ *
+ * This prevents cross-project IP leakage — e.g. CROWLR learnings
+ * won't appear when working on VOILA.
+ */
+export function listLearnings(category, projects) {
+    const store = loadStore();
+    let result = store.learnings;
+    if (projects && projects.length > 0) {
+        const lowerProjects = projects.map((p) => p.toLowerCase());
+        result = result.filter((l) => !l.project || lowerProjects.includes(l.project.toLowerCase()));
+    }
+    if (category) {
+        result = result.filter((l) => l.category.toLowerCase() === category.toLowerCase());
+    }
+    return result;
+}
+/**
+ * Delete a learning by ID.
+ */
+export function deleteLearning(id) {
+    const store = loadStore();
+    const index = store.learnings.findIndex((l) => l.id === id);
+    if (index === -1)
+        return false;
+    const removed = store.learnings[index];
+    store.learnings.splice(index, 1);
+    saveStore(store);
+    safeAppend("learning.delete", {
+        id: removed.id,
+        category: removed.category,
+        project: removed.project,
+        rule_length: typeof removed.rule === "string" ? removed.rule.length : 0,
+    });
+    return true;
+}
+export function importLearningsFromFile(filePath, defaultCategory = "other", defaultProject) {
+    if (!existsSync(filePath)) {
+        return { imported: 0, updated: 0, skipped: 0, errors: [`File not found: ${filePath}`] };
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    const result = ext === "json"
+        ? importFromJson(content, defaultProject)
+        : importFromMarkdown(content, defaultCategory, defaultProject);
+    // Aggregate event correlating the individual learning.save records emitted
+    // inside the loop. Useful for compliance attribution: "this batch came from
+    // file X".
+    safeAppend("learning.import", {
+        source: filePath,
+        format: ext === "json" ? "json" : "markdown",
+        project: defaultProject,
+        imported: result.imported,
+        updated: result.updated,
+        skipped: result.skipped,
+        errors: result.errors.length,
+    });
+    return result;
+}
+function importFromJson(content, defaultProject) {
+    const result = { imported: 0, updated: 0, skipped: 0, errors: [] };
+    try {
+        const data = JSON.parse(content);
+        const items = Array.isArray(data)
+            ? data
+            : data.learnings
+                ? data.learnings
+                : [];
+        for (const item of items) {
+            if (!item.rule || !item.category) {
+                result.skipped++;
+                result.errors.push(`Skipped entry missing rule or category: ${JSON.stringify(item).substring(0, 80)}`);
+                continue;
+            }
+            if (item.rule.trim().length < MIN_RULE_LENGTH) {
+                result.skipped++;
+                continue;
+            }
+            const cat = LEARNING_CATEGORIES.includes(item.category) ? item.category : "other";
+            const store = loadStore();
+            const existing = store.learnings.find((l) => l.category === cat && typeof l.rule === "string" && l.rule.toLowerCase().trim() === item.rule.toLowerCase().trim());
+            try {
+                saveLearning(cat, item.rule, item.context || "", item.project || defaultProject);
+                if (existing) {
+                    result.updated++;
+                }
+                else {
+                    result.imported++;
+                }
+            }
+            catch {
+                result.skipped++;
+            }
+        }
+    }
+    catch (e) {
+        result.errors.push(`JSON parse error: ${e.message}`);
+    }
+    return result;
+}
+function importFromMarkdown(content, defaultCategory, defaultProject) {
+    const result = { imported: 0, updated: 0, skipped: 0, errors: [] };
+    const lines = content.split("\n");
+    let currentCategory = defaultCategory;
+    let currentRule = "";
+    let currentContext = [];
+    function flushRule() {
+        if (!currentRule)
+            return;
+        // Quality gate: skip rules that are too short (catches junk from headings/bullets)
+        if (currentRule.trim().length < MIN_RULE_LENGTH) {
+            result.skipped++;
+            currentRule = "";
+            currentContext = [];
+            return;
+        }
+        const cat = normalizeCategory(currentCategory);
+        const ctx = currentContext.join(" ").trim() || `Imported from file`;
+        const store = loadStore();
+        const existing = store.learnings.find((l) => l.category === cat && typeof l.rule === "string" && l.rule.toLowerCase().trim() === currentRule.toLowerCase().trim());
+        try {
+            saveLearning(cat, currentRule, ctx, defaultProject);
+            if (existing) {
+                result.updated++;
+            }
+            else {
+                result.imported++;
+            }
+        }
+        catch {
+            result.skipped++;
+        }
+        currentRule = "";
+        currentContext = [];
+    }
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // H1 — file title, skip
+        if (trimmed.startsWith("# ") && !trimmed.startsWith("## "))
+            continue;
+        // H2 — category (e.g., "## deployment" or "## Security & Server Administration")
+        if (trimmed.startsWith("## ")) {
+            flushRule();
+            const heading = trimmed.replace(/^##\s+/, "").toLowerCase().trim();
+            currentCategory = heading;
+            continue;
+        }
+        // H3 — rule (e.g., "### Never docker build | tee")
+        if (trimmed.startsWith("### ")) {
+            flushRule();
+            const candidate = trimmed.replace(/^###\s+/, "").trim();
+            // Quality filter: skip short headings ("Fix", "UI", "DB")
+            if (candidate.length >= MIN_RULE_LENGTH) {
+                currentRule = candidate;
+            }
+            continue;
+        }
+        // H4+ — sub-rule, treat as context for current rule
+        if (trimmed.startsWith("#### ")) {
+            if (currentRule) {
+                currentContext.push(trimmed.replace(/^####\s+/, "").trim());
+            }
+            continue;
+        }
+        // Bullet with inline category: "- [deployment] Rule text → Context"
+        const inlineCatMatch = trimmed.match(/^[-*]\s+\[(\w+)\]\s+(.+)/);
+        if (inlineCatMatch) {
+            flushRule();
+            const [, cat, rest] = inlineCatMatch;
+            currentCategory = cat;
+            // Split on → or — for rule/context separation
+            const sepMatch = rest.match(/^(.+?)(?:\s*[→—]\s*|\s+[-–]\s+)(.+)$/);
+            if (sepMatch) {
+                const candidate = sepMatch[1].trim();
+                if (candidate.length >= MIN_RULE_LENGTH) {
+                    currentRule = candidate;
+                    currentContext = [sepMatch[2].trim()];
+                    flushRule();
+                }
+            }
+            else {
+                const candidate = rest.trim();
+                if (candidate.length >= MIN_RULE_LENGTH) {
+                    currentRule = candidate;
+                    flushRule();
+                }
+            }
+            continue;
+        }
+        // Table rows: | Pattern | Example | Description |
+        const tableMatch = trimmed.match(/^\|\s*\*\*(.+?)\*\*\s*\|(.+)\|(.+)\|/);
+        if (tableMatch) {
+            flushRule();
+            const candidate = tableMatch[1].trim();
+            if (candidate.length >= MIN_RULE_LENGTH) {
+                currentRule = candidate;
+                currentContext = [tableMatch[2].trim() + " — " + tableMatch[3].trim()];
+                flushRule();
+            }
+            continue;
+        }
+        // Regular bullet — either starts a new rule or adds context to current
+        if (trimmed.match(/^[-*]\s+\*\*(.+?)\*\*/)) {
+            // Bold-start bullet = likely a rule
+            flushRule();
+            const boldMatch = trimmed.match(/^[-*]\s+\*\*(.+?)\*\*\s*(.*)$/);
+            if (boldMatch) {
+                const candidate = boldMatch[1].trim();
+                // Quality filter: skip short/single-word headings
+                if (candidate.length < MIN_RULE_LENGTH) {
+                    continue;
+                }
+                currentRule = candidate;
+                if (boldMatch[2]) {
+                    // Strip leading separators
+                    currentContext = [boldMatch[2].replace(/^[\s—→:]+/, "").trim()];
+                }
+            }
+            continue;
+        }
+        // Regular bullet or numbered item — context for current rule
+        if ((trimmed.startsWith("- ") || trimmed.startsWith("* ") || trimmed.match(/^\d+\.\s/)) && currentRule) {
+            const text = trimmed.replace(/^[-*\d.]+\s+/, "").trim();
+            if (text)
+                currentContext.push(text);
+            continue;
+        }
+        // Plain text after a rule heading = context
+        if (currentRule && trimmed.length > 10 && !trimmed.startsWith("|") && !trimmed.startsWith("```")) {
+            currentContext.push(trimmed);
+        }
+    }
+    flushRule(); // Flush last rule
+    return result;
+}
+/** Infer a category from rule text + context when "other" is provided */
+function inferCategory(rule, context) {
+    const text = `${rule} ${context}`.toLowerCase();
+    const keywords = {
+        "deploy": "deployment", "rsync": "deployment", "publish": "deployment", "release": "deployment",
+        "ci/cd": "devops", "ci cd": "devops", "pipeline": "devops", "github actions": "devops", "docker": "devops",
+        "nginx": "infrastructure", "ssl": "infrastructure", "server": "infrastructure", "pm2": "infrastructure", "vps": "infrastructure",
+        "api": "api", "endpoint": "api", "rest": "api", "graphql": "api", "webhook": "api",
+        "sql": "database", "sqlite": "database", "mysql": "database", "postgres": "database", "query": "database", "migration": "database",
+        "react": "frontend", "vue": "frontend", "css": "frontend", "html": "frontend", "dom": "frontend", "component": "frontend", "ui": "frontend",
+        "express": "backend", "node": "backend", "flask": "backend", "middleware": "backend",
+        "auth": "security", "cors": "security", "xss": "security", "csrf": "security", "helmet": "security", "encrypt": "security", "password": "security",
+        "test": "testing", "vitest": "testing", "jest": "testing", "spec": "testing", "assert": "testing",
+        "debug": "debugging", "error": "debugging", "stack trace": "debugging", "breakpoint": "debugging", "log": "debugging",
+        "npm": "dependencies", "package": "dependencies", "yarn": "dependencies", "pnpm": "dependencies", "version": "dependencies",
+        "git": "git", "commit": "git", "branch": "git", "merge": "git", "rebase": "git",
+        "perf": "performance", "latency": "performance", "cache": "performance", "optimize": "performance",
+        "eslint": "tooling", "lint": "tooling", "prettier": "tooling", "vscode": "tooling", "editor": "tooling",
+        "pattern": "architecture", "refactor": "architecture", "module": "architecture", "design": "architecture",
+        "ios": "mobile", "android": "mobile", "expo": "mobile", "react native": "mobile",
+    };
+    for (const [keyword, cat] of Object.entries(keywords)) {
+        if (text.includes(keyword))
+            return cat;
+    }
+    return "other";
+}
+/** Map free-form heading text to closest LEARNING_CATEGORIES value */
+function normalizeCategory(heading) {
+    const h = heading.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim();
+    // Direct match
+    for (const cat of LEARNING_CATEGORIES) {
+        if (h === cat || h.startsWith(cat))
+            return cat;
+    }
+    // Keyword mapping
+    const map = {
+        "deploy": "deployment",
+        "ci/cd": "devops",
+        "ci cd": "devops",
+        "pipeline": "devops",
+        "docker": "devops",
+        "nginx": "infrastructure",
+        "server": "infrastructure",
+        "hosting": "infrastructure",
+        "ssl": "security",
+        "cors": "security",
+        "auth": "security",
+        "malware": "security",
+        "hack": "security",
+        "hardening": "security",
+        "terminal": "tooling",
+        "command": "tooling",
+        "monitoring": "tooling",
+        "vs code": "tooling",
+        "test": "testing",
+        "jest": "testing",
+        "spec": "testing",
+        "debug": "debugging",
+        "bug": "debugging",
+        "fix": "debugging",
+        "react": "frontend",
+        "vue": "frontend",
+        "css": "frontend",
+        "ui": "frontend",
+        "laravel": "backend",
+        "django": "backend",
+        "flask": "backend",
+        "express": "backend",
+        "mysql": "database",
+        "postgres": "database",
+        "sql": "database",
+        "migration": "database",
+        "npm": "dependencies",
+        "composer": "dependencies",
+        "pip": "dependencies",
+        "package": "dependencies",
+        "git": "git",
+        "commit": "git",
+        "branch": "git",
+        "hook": "git",
+        "perf": "performance",
+        "speed": "performance",
+        "cache": "performance",
+        "mobile": "mobile",
+        "expo": "mobile",
+        "flutter": "mobile",
+        "react native": "mobile",
+        "swift": "mobile",
+        "pattern": "architecture",
+        "design": "architecture",
+        "struct": "architecture",
+        "data type": "data",
+        "csv": "data",
+        "import": "data",
+        "export": "data",
+        "api": "api",
+        "endpoint": "api",
+        "rest": "api",
+        "smtp": "infrastructure",
+        "email": "infrastructure",
+        "queue": "infrastructure",
+        "audit": "security",
+        "version": "dependencies",
+        "upgrade": "dependencies",
+    };
+    for (const [keyword, cat] of Object.entries(map)) {
+        if (h.includes(keyword))
+            return cat;
+    }
+    return "other";
+}
+/**
+ * Convert learnings to Chunks so they can be included in search_context.
+ * This is the key integration — learnings auto-surface in hybrid search.
+ *
+ * When `projects` is provided, only includes learnings for those projects
+ * (+ universal learnings with no project). This prevents cross-project
+ * IP leakage — CROWLR secrets won't appear when searching in VOILA.
+ */
+export function learningsToChunks(projects) {
+    const store = loadStore();
+    let learnings = store.learnings;
+    if (projects && projects.length > 0) {
+        const lowerProjects = projects.map((p) => p.toLowerCase());
+        learnings = learnings.filter((l) => !l.project || lowerProjects.includes(l.project.toLowerCase()));
+    }
+    return learnings.map((l) => ({
+        source: "💡 Learnings Store",
+        section: `[${l.category}] ${l.rule}`,
+        content: [
+            `**Rule:** ${l.rule}`,
+            `**Category:** ${l.category}`,
+            l.project ? `**Project:** ${l.project}` : "",
+            l.context ? `**Context:** ${l.context}` : "",
+            l.tags?.length ? `**Tags:** ${l.tags.join(", ")}` : "",
+            l.created ? `_Learned: ${l.created.split("T")[0]}_` : "",
+        ]
+            .filter(Boolean)
+            .join("\n"),
+        lineStart: 0,
+        lineEnd: 0,
+    }));
+}
+/**
+ * Auto-import learnings from discovered knowledge source files.
+ *
+ * Called during reindex — scans all source markdown files and extracts
+ * rules into the permanent learning store. Deduplication is built-in,
+ * so calling repeatedly on the same files is safe (no duplicates).
+ *
+ * This ensures documentation rules become searchable learnings without
+ * requiring the user or agent to manually trigger `import_learnings`.
+ */
+export function autoImportFromSources(sources) {
+    let totalImported = 0;
+    let totalUpdated = 0;
+    let processed = 0;
+    for (const source of sources) {
+        // Only process markdown files
+        if (!source.path.endsWith(".md"))
+            continue;
+        if (!existsSync(source.path))
+            continue;
+        // Extract project name from source name (e.g., "ContextEngine — copilot-instructions.md")
+        const project = source.name.split(" — ")[0]?.trim() || undefined;
+        const result = importLearningsFromFile(source.path, "other", project);
+        totalImported += result.imported;
+        totalUpdated += result.updated;
+        if (result.imported > 0 || result.updated > 0)
+            processed++;
+    }
+    return { total: processed, imported: totalImported, updated: totalUpdated };
+}
+/**
+ * Get the store stats.
+ */
+export function learningsStats() {
+    const store = loadStore();
+    const categories = {};
+    for (const l of store.learnings) {
+        categories[l.category] = (categories[l.category] || 0) + 1;
+    }
+    return { total: store.learnings.length, categories };
+}
+/**
+ * Format learnings for display.
+ */
+export function formatLearnings(learnings) {
+    if (learnings.length === 0) {
+        return "No learnings stored yet. Use `save_learning` to add operational rules.";
+    }
+    const lines = [];
+    lines.push(`# 💡 Learnings Store (${learnings.length} rules)\n`);
+    // Group by category
+    const byCategory = new Map();
+    for (const l of learnings) {
+        const list = byCategory.get(l.category) || [];
+        list.push(l);
+        byCategory.set(l.category, list);
+    }
+    for (const [category, items] of byCategory) {
+        lines.push(`## ${category} (${items.length})\n`);
+        for (const l of items) {
+            lines.push(`### ${l.rule}`);
+            lines.push(`- **ID:** \`${l.id}\``);
+            if (l.project)
+                lines.push(`- **Project:** ${l.project}`);
+            if (l.context)
+                lines.push(`- **Context:** ${l.context}`);
+            if (l.tags?.length)
+                lines.push(`- **Tags:** ${l.tags.join(", ")}`);
+            if (l.created)
+                lines.push(`- **Learned:** ${l.created.split("T")[0]}`);
+            lines.push("");
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=learnings.js.map