fraim 2.0.100

package/dist/src/local-mcp-server/learning-context-builder.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * LearningContextBuilder builds the learning context section for a user.
+ *
+ * Lives in the local proxy so learning files are always read from the correct
+ * workspace root on the user's machine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLearningContextSection = buildLearningContextSection;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const LEARNINGS_REL = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee/learnings').replace(/\/$/, '');
+const DEFAULT_THRESHOLD = 3.0;
+function getLearningsBase(workspaceRoot) {
+    return (0, path_1.join)(workspaceRoot, LEARNINGS_REL);
+}
+function getScoreThreshold(workspaceRoot) {
+    try {
+        const configPath = (0, project_fraim_paths_1.getWorkspaceConfigPath)(workspaceRoot);
+        if ((0, fs_1.existsSync)(configPath)) {
+            const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf8'));
+            const t = config?.learning?.scoreThreshold;
+            if (typeof t === 'number' && t > 0)
+                return t;
+        }
+    }
+    catch {
+        // Fall through to default.
+    }
+    return DEFAULT_THRESHOLD;
+}
+function computeEffectiveScore(severity, lastSeenDate, recurrences, fileType) {
+    const baseScore = severity === 'P-HIGH' ? 8 : severity === 'P-MED' ? 5 : 3;
+    const halfLife = fileType === 'mistake-patterns' ? 90 : 180;
+    let daysSinceLastSeen = 0;
+    try {
+        const lastSeen = new Date(lastSeenDate);
+        const now = new Date();
+        daysSinceLastSeen = Math.max(0, (now.getTime() - lastSeen.getTime()) / (1000 * 60 * 60 * 24));
+    }
+    catch {
+        // Treat as fresh.
+    }
+    const decay = Math.pow(0.5, daysSinceLastSeen / halfLife);
+    const recurrenceBoost = Math.log2(Math.max(1, recurrences) + 1);
+    return baseScore * decay * recurrenceBoost;
+}
+function countMistakePatternEntries(filePath, threshold) {
+    if (!(0, fs_1.existsSync)(filePath))
+        return { active: 0, dormant: 0 };
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+        const lines = content.split('\n');
+        let active = 0;
+        let dormant = 0;
+        let inEntry = false;
+        let currentSeverity = null;
+        let currentLastSeen = '';
+        let currentRecurrences = 1;
+        const processCurrentEntry = () => {
+            if (!currentSeverity)
+                return;
+            const score = computeEffectiveScore(currentSeverity, currentLastSeen, currentRecurrences, 'mistake-patterns');
+            if (score >= threshold)
+                active++;
+            else
+                dormant++;
+        };
+        for (const line of lines) {
+            const headerMatch = line.match(/^## \[(P-HIGH|P-MED|P-LOW)\]/);
+            if (headerMatch) {
+                processCurrentEntry();
+                inEntry = true;
+                currentSeverity = headerMatch[1];
+                currentLastSeen = '';
+                currentRecurrences = 1;
+                continue;
+            }
+            if (!inEntry)
+                continue;
+            const lastSeenMatch = line.match(/^\*\*Last seen\*\*:\s*(.+)/);
+            if (lastSeenMatch) {
+                currentLastSeen = lastSeenMatch[1].trim();
+                continue;
+            }
+            const recurrenceMatch = line.match(/^\*\*Recurrences\*\*:\s*(\d+)/);
+            if (recurrenceMatch) {
+                currentRecurrences = parseInt(recurrenceMatch[1], 10);
+            }
+        }
+        processCurrentEntry();
+        return { active, dormant };
+    }
+    catch {
+        return { active: 0, dormant: 0 };
+    }
+}
+function readFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return {};
+    const frontmatter = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const separator = line.indexOf(':');
+        if (separator === -1)
+            continue;
+        const key = line.slice(0, separator).trim();
+        const value = line.slice(separator + 1).trim();
+        if (key) {
+            frontmatter[key] = value;
+        }
+    }
+    return frontmatter;
+}
+function isUnsynthesizedRetrospective(filePath) {
+    try {
+        const content = (0, fs_1.readFileSync)(filePath, 'utf8');
+        const frontmatter = readFrontmatter(content);
+        const synthesized = frontmatter.synthesized?.toLowerCase();
+        return synthesized !== 'true' && synthesized !== 'yes';
+    }
+    catch {
+        return false;
+    }
+}
+function buildLearningContextSection(workspaceRoot, userId, forJob) {
+    const learningsBase = getLearningsBase(workspaceRoot);
+    const threshold = getScoreThreshold(workspaceRoot);
+    const l2MistakePath = (0, path_1.join)(learningsBase, 'org-mistake-patterns.md');
+    const l2PrefPath = (0, path_1.join)(learningsBase, 'org-preferences.md');
+    const l2CoachPath = (0, path_1.join)(learningsBase, 'org-manager-coaching.md');
+    const l2MistakePresent = (0, fs_1.existsSync)(l2MistakePath);
+    const l2PrefPresent = (0, fs_1.existsSync)(l2PrefPath);
+    const l2CoachPresent = (0, fs_1.existsSync)(l2CoachPath);
+    const l2MistakeCounts = l2MistakePresent ? countMistakePatternEntries(l2MistakePath, threshold) : null;
+    const l1MistakePath = (0, path_1.join)(learningsBase, `${userId}-mistake-patterns.md`);
+    const l1PrefPath = (0, path_1.join)(learningsBase, `${userId}-preferences.md`);
+    const l1CoachPath = (0, path_1.join)(learningsBase, `${userId}-manager-coaching.md`);
+    const l1MistakePresent = (0, fs_1.existsSync)(l1MistakePath);
+    const l1PrefPresent = (0, fs_1.existsSync)(l1PrefPath);
+    const l1CoachPresent = (0, fs_1.existsSync)(l1CoachPath);
+    const l1MistakeCounts = l1MistakePresent ? countMistakePatternEntries(l1MistakePath, threshold) : null;
+    let l0CoachingCount = 0;
+    const rawPath = (0, path_1.join)(learningsBase, 'raw');
+    if ((0, fs_1.existsSync)(rawPath)) {
+        try {
+            l0CoachingCount = (0, fs_1.readdirSync)(rawPath).filter(f => f.startsWith(`${userId}-`)).length;
+        }
+        catch {
+            // Ignore read failures.
+        }
+    }
+    let l0RetroCount = 0;
+    const retrospectivesPath = (0, path_1.join)(workspaceRoot, 'docs', 'retrospectives');
+    if ((0, fs_1.existsSync)(retrospectivesPath)) {
+        try {
+            l0RetroCount = (0, fs_1.readdirSync)(retrospectivesPath)
+                .filter(f => f.startsWith(`${userId}-`) && f.endsWith('.md'))
+                .filter(f => isUnsynthesizedRetrospective((0, path_1.join)(retrospectivesPath, f))).length;
+        }
+        catch {
+            // Ignore read failures.
+        }
+    }
+    const hasL2 = l2MistakePresent || l2PrefPresent || l2CoachPresent;
+    const hasL1 = l1MistakePresent || l1PrefPresent || l1CoachPresent;
+    const hasContent = hasL2 || hasL1 || l0CoachingCount > 0 || l0RetroCount > 0;
+    if (!hasContent)
+        return '';
+    let section = forJob
+        ? '\n\n## Learning Context for This Job\n\n'
+        : '\n\n## Learning Context\n\n';
+    if (hasL2) {
+        section += '### L2 - Org patterns\n';
+        if (l2MistakePresent)
+            section += `\`${LEARNINGS_REL}/org-mistake-patterns.md\`  (entries above score threshold)\n`;
+        if (l2PrefPresent)
+            section += `\`${LEARNINGS_REL}/org-preferences.md\`  (all entries)\n`;
+        if (l2CoachPresent)
+            section += `\`${LEARNINGS_REL}/org-manager-coaching.md\`  (all entries)\n`;
+        if (l2MistakeCounts && l2MistakeCounts.dormant > 0) {
+            section += `Dormant: ${l2MistakeCounts.dormant} org pattern${l2MistakeCounts.dormant !== 1 ? 's' : ''} below threshold\n`;
+        }
+        section += '\n';
+    }
+    if (hasL1) {
+        section += '### L1 - Your patterns\n';
+        if (l1PrefPresent)
+            section += `\`${LEARNINGS_REL}/${userId}-preferences.md\`  (all entries)\n`;
+        if (l1CoachPresent)
+            section += `\`${LEARNINGS_REL}/${userId}-manager-coaching.md\`  (all entries)\n`;
+        if (l1MistakePresent)
+            section += `\`${LEARNINGS_REL}/${userId}-mistake-patterns.md\`  (entries above score threshold)\n`;
+        if (l1MistakeCounts && l1MistakeCounts.dormant > 0) {
+            section += `Dormant: ${l1MistakeCounts.dormant} personal pattern${l1MistakeCounts.dormant !== 1 ? 's' : ''} below threshold\n`;
+        }
+        section += '\n';
+    }
+    if (l0CoachingCount > 0 || l0RetroCount > 0) {
+        section += '### L0 - Your unprocessed signals\n';
+        if (l0CoachingCount > 0) {
+            section += `${l0CoachingCount} coaching moment${l0CoachingCount !== 1 ? 's' : ''} in \`${LEARNINGS_REL}/raw/${userId}-*\`\n`;
+        }
+        if (l0RetroCount > 0) {
+            section += `${l0RetroCount} retrospective${l0RetroCount !== 1 ? 's' : ''} in \`docs/retrospectives/${userId}-*\` with \`synthesized: false\` or missing\n`;
+        }
+        section += '\n';
+    }
+    const totalL0 = l0CoachingCount + l0RetroCount;
+    if (forJob) {
+        if (hasL2 || hasL1) {
+            section += 'Use the relevant patterns, preferences, and coaching signals in this job.\n';
+        }
+        if (totalL0 >= 5) {
+            section += '\n';
+            section += `Warning: ${totalL0} unprocessed signals pending. Consider running \`end-of-day-debrief\` before starting today's work.\n`;
+        }
+    }
+    else {
+        section += 'Use this synthesized learning context throughout the session.\n';
+        if (totalL0 >= 5) {
+            section += '\n';
+            section += `Warning: synthesis overdue with ${totalL0} unprocessed signals.\n`;
+            section += 'Run `end-of-day-debrief` before starting today\'s work.\n';
+        }
+    }
+    return section;
+}