codymaster 4.8.0 → 7.0.0

package/dist/learning-promoter.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningPromoter = void 0;
+exports.formatPromotionCandidates = formatPromotionCandidates;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const storage_backend_1 = require("./storage-backend");
+// ─── Constants ──────────────────────────────────────────────────────────────
+const MIN_REINFORCEMENT = 3; // Minimum times a learning must be reinforced
+const MIN_PROMOTION_SCORE = 0.50; // Minimum score to qualify for promotion
+const PROMOTION_LOG = '.cm/evolution/promotions.jsonl';
+// ─── Learning Promoter ──────────────────────────────────────────────────────
+// TRIZ #22 "Blessing in Disguise" — failures become reusable knowledge
+/**
+ * LearningPromoter — Promotes mature learnings into reusable skills.
+ *
+ * When a learning has been reinforced enough times (appearing in multiple
+ * execution analyses or being manually confirmed), it graduates from
+ * ephemeral memory into a permanent skill entry.
+ *
+ * Flow:
+ *   1. Scan learnings in SQLite for candidates with high reinforcement
+ *   2. Score each candidate based on: reinforcement count, recency, category
+ *   3. Generate a minimal SKILL.md from the learning content
+ *   4. Save to skills/ directory
+ */
+class LearningPromoter {
+    constructor(projectPath, backend) {
+        this.projectPath = projectPath;
+        this.backend = backend !== null && backend !== void 0 ? backend : (0, storage_backend_1.getBackend)(projectPath);
+        this.backend.initialize();
+        this.skillsDir = this.findSkillsDir();
+    }
+    /**
+     * Find learnings that qualify for promotion.
+     */
+    findCandidates(limit = 10) {
+        var _a;
+        // Query all learnings and count reinforcement (same what_failed pattern)
+        const allLearnings = this.backend.queryLearnings('', undefined, 200);
+        const patternCounts = new Map();
+        for (const learning of allLearnings) {
+            const pattern = this.normalizePattern(learning.what_failed);
+            const existing = (_a = patternCounts.get(pattern)) !== null && _a !== void 0 ? _a : { count: 0, learnings: [] };
+            existing.count++;
+            existing.learnings.push(learning);
+            patternCounts.set(pattern, existing);
+        }
+        const candidates = [];
+        for (const [_pattern, { count, learnings }] of patternCounts) {
+            if (count < MIN_REINFORCEMENT)
+                continue;
+            // Use the most recent learning as the representative
+            const representative = learnings.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+            const score = this.calculateScore(count, representative);
+            if (score >= MIN_PROMOTION_SCORE) {
+                candidates.push({
+                    learning: representative,
+                    reinforcementCount: count,
+                    score,
+                    reason: `Reinforced ${count}x, score ${(score * 100).toFixed(0)}%`,
+                });
+            }
+        }
+        return candidates
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Promote a specific learning to a skill.
+     */
+    promote(learningId) {
+        const learning = this.backend.getLearningById(learningId);
+        if (!learning) {
+            return {
+                promoted: false,
+                skillName: '',
+                skillPath: '',
+                learningId,
+                reason: `Learning ${learningId} not found.`,
+            };
+        }
+        // Generate skill name from the learning content
+        const skillName = this.generateSkillName(learning);
+        const skillDir = path_1.default.join(this.skillsDir, skillName);
+        if (fs_1.default.existsSync(skillDir)) {
+            return {
+                promoted: false,
+                skillName,
+                skillPath: skillDir,
+                learningId,
+                reason: `Skill ${skillName} already exists.`,
+            };
+        }
+        // Generate the SKILL.md content
+        const skillContent = this.generateSkillContent(learning, skillName);
+        // Create the skill
+        fs_1.default.mkdirSync(skillDir, { recursive: true });
+        const skillPath = path_1.default.join(skillDir, 'SKILL.md');
+        fs_1.default.writeFileSync(skillPath, skillContent, 'utf-8');
+        // Log the promotion
+        this.logPromotion(learningId, skillName, skillPath);
+        return {
+            promoted: true,
+            skillName,
+            skillPath,
+            learningId,
+            reason: `Learning promoted to skill: ${skillName}`,
+        };
+    }
+    /**
+     * Auto-promote: find candidates and promote the top one.
+     */
+    autoPromote() {
+        const candidates = this.findCandidates(1);
+        if (candidates.length === 0)
+            return null;
+        return this.promote(candidates[0].learning.id);
+    }
+    /**
+     * Get promotion history.
+     */
+    getPromotionHistory(limit = 20) {
+        const logPath = path_1.default.join(this.projectPath, PROMOTION_LOG);
+        if (!fs_1.default.existsSync(logPath))
+            return [];
+        const lines = fs_1.default.readFileSync(logPath, 'utf-8').trim().split('\n').filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch ( /* skip */_a) { /* skip */ }
+        }
+        return entries.slice(-limit).reverse();
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────────
+    findSkillsDir() {
+        const candidates = [
+            path_1.default.join(this.projectPath, 'skills'),
+            path_1.default.join(this.projectPath, '.agent', 'skills'),
+        ];
+        for (const dir of candidates) {
+            if (fs_1.default.existsSync(dir))
+                return dir;
+        }
+        return path_1.default.join(this.projectPath, 'skills');
+    }
+    normalizePattern(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim()
+            .split(' ')
+            .sort()
+            .join(' ');
+    }
+    calculateScore(reinforcementCount, learning) {
+        // Reinforcement factor (0-0.5): more reinforcement = higher score
+        const reinforcementFactor = Math.min(0.5, reinforcementCount / 10);
+        // Recency factor (0-0.3): newer learnings score higher
+        const daysSince = (Date.now() - new Date(learning.created_at).getTime()) / (1000 * 60 * 60 * 24);
+        const recencyFactor = Math.max(0, 0.3 - (daysSince / 365) * 0.3);
+        // Content quality factor (0-0.2): longer, more detailed = better
+        const contentLength = (learning.what_failed.length + learning.how_to_prevent.length);
+        const qualityFactor = Math.min(0.2, contentLength / 500 * 0.2);
+        return reinforcementFactor + recencyFactor + qualityFactor;
+    }
+    generateSkillName(learning) {
+        const words = learning.what_failed
+            .toLowerCase()
+            .replace(/[^\w\s]/g, '')
+            .split(/\s+/)
+            .filter(w => w.length > 3)
+            .slice(0, 3);
+        const base = words.length > 0 ? words.join('-') : 'promoted';
+        return `cm-learned-${base}`;
+    }
+    generateSkillContent(learning, skillName) {
+        return [
+            '---',
+            `name: ${skillName}`,
+            `description: Auto-promoted from reinforced learning`,
+            '---',
+            '',
+            `# ${skillName}`,
+            '',
+            `> 🎓 Auto-promoted from learning on ${new Date().toISOString().split('T')[0]}`,
+            `> Original module: ${learning.module}`,
+            `> Agent: ${learning.agent}`,
+            '',
+            '## Problem Pattern',
+            '',
+            learning.what_failed,
+            '',
+            '## Root Cause',
+            '',
+            learning.why_failed,
+            '',
+            '## Prevention / Solution',
+            '',
+            learning.how_to_prevent,
+            '',
+            '## When to Apply',
+            '',
+            `Apply this skill when encountering patterns similar to: "${learning.what_failed.slice(0, 100)}"`,
+            '',
+            '## Steps',
+            '',
+            `1. Recognize the problem pattern described above`,
+            `2. Apply the prevention strategy: ${learning.how_to_prevent.slice(0, 100)}`,
+            `3. Verify the fix resolves the root cause`,
+            '',
+        ].join('\n');
+    }
+    logPromotion(learningId, skillName, skillPath) {
+        const logPath = path_1.default.join(this.projectPath, PROMOTION_LOG);
+        const dir = path_1.default.dirname(logPath);
+        if (!fs_1.default.existsSync(dir))
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        const entry = { learningId, skillName, skillPath, promotedAt: new Date().toISOString() };
+        fs_1.default.appendFileSync(logPath, JSON.stringify(entry) + '\n');
+    }
+}
+exports.LearningPromoter = LearningPromoter;
+// ─── Display Helpers ─────────────────────────────────────────────────────────
+function formatPromotionCandidates(candidates) {
+    if (candidates.length === 0)
+        return 'No learnings qualify for promotion yet. Need ≥3 reinforcements.';
+    const lines = [
+        '🎓 Learning → Skill Promotion Candidates',
+        '─'.repeat(70),
+        `${'Score'.padEnd(8)} ${'Reinf'.padEnd(8)} Pattern`,
+        '─'.repeat(70),
+    ];
+    for (const c of candidates) {
+        const score = (c.score * 100).toFixed(0) + '%';
+        const pattern = c.learning.what_failed.slice(0, 50);
+        lines.push(`${score.padEnd(8)} ${(c.reinforcementCount + 'x').padEnd(8)} ${pattern}`);
+    }
+    return lines.join('\n');
+}

package/dist/learnings.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * Per-project learnings — append-only JSONL log under `.cm/learnings.jsonl`.
+ *
+ * Each learning is a small structured note that future sessions read at start
+ * (via cm-continuity) so the agent doesn't repeat past pitfalls or forget
+ * preferences. Inspired by gstack `/learn` but simpler — no sync required.
+ *
+ * Format (one JSON object per line):
+ *   { "ts": "2026-05-07T12:00:00Z",
+ *     "type": "pitfall" | "preference" | "pattern" | "fact",
+ *     "scope": "deploy" | "ui" | "test" | ...,
+ *     "note": "human readable note",
+ *     "source": "cm-retro-cli" | "manual" | ... }
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LearningError = void 0;
+exports.learningsPath = learningsPath;
+exports.addLearning = addLearning;
+exports.listLearnings = listLearnings;
+exports.pruneLearnings = pruneLearnings;
+exports.anonymize = anonymize;
+exports.learningKey = learningKey;
+exports.mergeLearnings = mergeLearnings;
+exports.readLearningsFile = readLearningsFile;
+exports.writeLearningsFile = writeLearningsFile;
+exports.renderLearningsForContinuity = renderLearningsForContinuity;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const LEARNING_TYPES = new Set(['pitfall', 'preference', 'pattern', 'fact']);
+function learningsPath(projectPath) {
+    return path_1.default.join(projectPath, '.cm', 'learnings.jsonl');
+}
+function ensureDir(file) {
+    const d = path_1.default.dirname(file);
+    if (!fs_1.default.existsSync(d))
+        fs_1.default.mkdirSync(d, { recursive: true });
+}
+class LearningError extends Error {
+}
+exports.LearningError = LearningError;
+function validate(input) {
+    if (!LEARNING_TYPES.has(input.type)) {
+        throw new LearningError(`invalid learning type: ${input.type}`);
+    }
+    if (!input.scope || typeof input.scope !== 'string') {
+        throw new LearningError('learning.scope is required (string)');
+    }
+    if (!input.note || typeof input.note !== 'string') {
+        throw new LearningError('learning.note is required (string)');
+    }
+    if (input.note.length > 500) {
+        throw new LearningError(`learning.note too long (${input.note.length} > 500)`);
+    }
+}
+function addLearning(projectPath, input) {
+    var _a;
+    validate(input);
+    const learning = Object.assign({ ts: (_a = input.ts) !== null && _a !== void 0 ? _a : new Date().toISOString(), type: input.type, scope: input.scope, note: input.note }, (input.source ? { source: input.source } : {}));
+    const file = learningsPath(projectPath);
+    ensureDir(file);
+    fs_1.default.appendFileSync(file, JSON.stringify(learning) + '\n', 'utf8');
+    return learning;
+}
+function listLearnings(projectPath, query = {}) {
+    const file = learningsPath(projectPath);
+    if (!fs_1.default.existsSync(file))
+        return [];
+    const raw = fs_1.default.readFileSync(file, 'utf8');
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (_a) {
+            continue; // skip malformed lines
+        }
+        if (query.type && parsed.type !== query.type)
+            continue;
+        if (query.scope && parsed.scope !== query.scope)
+            continue;
+        if (query.since && parsed.ts < query.since)
+            continue;
+        out.push(parsed);
+    }
+    // Newest first.
+    out.reverse();
+    if (query.limit && out.length > query.limit)
+        return out.slice(0, query.limit);
+    return out;
+}
+/**
+ * Remove learnings older than `maxAgeDays` (default 180).
+ * Returns the number of pruned entries.
+ */
+function pruneLearnings(projectPath, maxAgeDays = 180) {
+    const file = learningsPath(projectPath);
+    if (!fs_1.default.existsSync(file))
+        return 0;
+    const cutoff = new Date(Date.now() - maxAgeDays * 24 * 60 * 60 * 1000).toISOString();
+    const raw = fs_1.default.readFileSync(file, 'utf8');
+    const kept = [];
+    let pruned = 0;
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed.ts >= cutoff) {
+                kept.push(line);
+            }
+            else {
+                pruned++;
+            }
+        }
+        catch (_a) {
+            kept.push(line); // keep malformed lines as-is
+        }
+    }
+    fs_1.default.writeFileSync(file, kept.join('\n') + (kept.length ? '\n' : ''), 'utf8');
+    return pruned;
+}
+/**
+ * Strip user-identifying / token-looking material from a learning before it
+ * leaves the project. Used by `cm learn sync` to push to a shared remote
+ * without leaking absolute paths, emails, or long credentials.
+ */
+function anonymize(l) {
+    const stripPath = (s) => s
+        .replace(/\/Users\/[^/\s"']+/g, '~')
+        .replace(/\/home\/[^/\s"']+/g, '~')
+        .replace(/[A-Za-z]:\\Users\\[^\\\s"']+/g, '~');
+    const stripEmail = (s) => s.replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '<email>');
+    const stripToken = (s) => 
+    // Long opaque tokens — runs of 24+ url-safe chars without spaces.
+    s.replace(/[A-Za-z0-9_\-]{24,}/g, '<token>');
+    const clean = (s) => stripToken(stripEmail(stripPath(s)));
+    return Object.assign({ ts: l.ts, type: l.type, scope: clean(l.scope), note: clean(l.note) }, (l.source ? { source: clean(l.source) } : {}));
+}
+/**
+ * Stable identity hash for dedup across machines. Excludes `ts` so the same
+ * note appearing on two days collapses to one entry.
+ */
+function learningKey(l) {
+    return `${l.type}|${l.scope}|${l.note}`;
+}
+/**
+ * Merge two learning lists, dropping duplicates by `learningKey`. The earliest
+ * timestamp wins (we treat the original observation as canonical).
+ */
+function mergeLearnings(a, b) {
+    const map = new Map();
+    for (const l of [...a, ...b]) {
+        const k = learningKey(l);
+        const prev = map.get(k);
+        if (!prev || l.ts < prev.ts)
+            map.set(k, l);
+    }
+    return Array.from(map.values()).sort((x, y) => (x.ts < y.ts ? -1 : 1));
+}
+/**
+ * Read the JSONL file at an arbitrary path (used by sync to read the remote
+ * mirror copy). Returns [] if the file is missing.
+ */
+function readLearningsFile(file) {
+    if (!fs_1.default.existsSync(file))
+        return [];
+    const out = [];
+    for (const line of fs_1.default.readFileSync(file, 'utf8').split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch (_a) {
+            // skip malformed
+        }
+    }
+    return out;
+}
+function writeLearningsFile(file, list) {
+    const dir = path_1.default.dirname(file);
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const body = list.map(l => JSON.stringify(l)).join('\n');
+    fs_1.default.writeFileSync(file, list.length ? body + '\n' : '', 'utf8');
+}
+/**
+ * Render the most recent N learnings as a compact Markdown block, suitable
+ * for injection into CONTINUITY.md by cm-continuity at session start.
+ */
+function renderLearningsForContinuity(projectPath, limit = 10) {
+    const recent = listLearnings(projectPath, { limit });
+    if (recent.length === 0)
+        return '';
+    const lines = ['## Recent Learnings (auto-loaded)'];
+    for (const l of recent) {
+        const date = l.ts.slice(0, 10);
+        lines.push(`- [${date}] **${l.type}/${l.scope}**: ${l.note}`);
+    }
+    return lines.join('\n') + '\n';
+}