ai-dev-analytics 1.1.1 → 1.1.3

package/dist/utils/memory.js

@@ -0,0 +1,657 @@
+import { readdirSync, statSync } from 'node:fs';
+import { basename, resolve } from 'node:path';
+import { ensureDir, fileExists, readJson, readText, writeJson, writeText } from './fs.js';
+import { branchDir, memoriesDir, memoryIndexPath, moduleMemoriesDir, moduleMemoryPath, moduleMemoryViewPath, requirementPath, runContextPath, runMemoryPackViewPath, runContextViewPath, runsDir, } from './paths.js';
+function uniqueStrings(values) {
+    const result = [];
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = `${value || ''}`.trim();
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(normalized);
+    }
+    return result;
+}
+function topItems(values, limit = 8) {
+    return uniqueStrings(values).slice(0, limit);
+}
+function walkJsonFiles(rootDir) {
+    if (!fileExists(rootDir))
+        return [];
+    const result = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        for (const name of readdirSync(current)) {
+            const full = resolve(current, name);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                stack.push(full);
+            }
+            else if (name.endsWith('.json')) {
+                result.push(full);
+            }
+        }
+    }
+    return result.sort();
+}
+function walkRunJsonFiles(rootDir) {
+    if (!fileExists(rootDir))
+        return [];
+    const result = [];
+    for (const branchName of readdirSync(rootDir)) {
+        const branchPath = resolve(rootDir, branchName);
+        if (!statSync(branchPath).isDirectory())
+            continue;
+        for (const child of readdirSync(branchPath)) {
+            const runPath = resolve(branchPath, child, 'run.json');
+            if (fileExists(runPath))
+                result.push(runPath);
+        }
+    }
+    return result.sort();
+}
+function extractTicket(value) {
+    const match = value.match(/\b([A-Z]{2,}-\d+)\b/);
+    return match?.[1];
+}
+function extractMarkdownSections(raw) {
+    const sections = new Map();
+    let current = '__lead__';
+    let buffer = [];
+    const flush = () => {
+        const text = buffer.join('\n').trim();
+        if (text)
+            sections.set(current.toLowerCase(), text);
+        buffer = [];
+    };
+    for (const line of raw.split('\n')) {
+        const heading = line.match(/^#{1,6}\s+(.+)$/);
+        if (heading) {
+            flush();
+            current = heading[1].trim();
+        }
+        else {
+            buffer.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function extractBulletItems(raw) {
+    const items = [];
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const bullet = trimmed.match(/^[-*]\s+(.+)$/);
+        const ordered = trimmed.match(/^\d+\.\s+(.+)$/);
+        if (bullet)
+            items.push(bullet[1].trim());
+        else if (ordered)
+            items.push(ordered[1].trim());
+    }
+    return uniqueStrings(items);
+}
+function findSectionItems(raw, keys) {
+    const sections = extractMarkdownSections(raw);
+    for (const [heading, content] of sections) {
+        if (keys.some((key) => heading.includes(key))) {
+            const items = extractBulletItems(content);
+            if (items.length > 0)
+                return items;
+        }
+    }
+    return [];
+}
+function extractSummaryFromAnalysis(raw) {
+    const sections = extractMarkdownSections(raw);
+    for (const [heading, content] of sections) {
+        if (heading.includes('概述') || heading.includes('摘要') || heading.includes('summary') || heading.includes('overview')) {
+            const paragraph = content
+                .split('\n')
+                .map((line) => line.trim())
+                .find((line) => line && !line.startsWith('- ') && !line.startsWith('* ') && !line.startsWith('>'));
+            if (paragraph)
+                return paragraph;
+        }
+    }
+    const lead = sections.get('__lead__');
+    if (!lead)
+        return '';
+    return lead
+        .split('\n')
+        .map((line) => line.trim())
+        .find((line) => line && !line.startsWith('#') && !line.startsWith('- ') && !line.startsWith('* '))
+        || '';
+}
+function loadRequirement(projectRoot, branchName) {
+    const path = requirementPath(projectRoot, branchName);
+    if (!fileExists(path))
+        return null;
+    return readJson(path);
+}
+function loadAnalysis(projectRoot, branchName) {
+    const path = resolve(branchDir(projectRoot, branchName), 'analysis.md');
+    if (!fileExists(path))
+        return '';
+    return readText(path);
+}
+function loadBranchRuns(projectRoot, branchName) {
+    const dir = branchDir(projectRoot, branchName);
+    if (!fileExists(dir))
+        return [];
+    const runs = [];
+    for (const child of readdirSync(dir)) {
+        const runPath = resolve(dir, child, 'run.json');
+        if (fileExists(runPath)) {
+            try {
+                runs.push(readJson(runPath));
+            }
+            catch {
+                // Ignore invalid legacy run files during migration.
+            }
+        }
+    }
+    return runs;
+}
+function pickKeyFiles(runs) {
+    const score = new Map();
+    for (const run of runs) {
+        for (const file of run.files || []) {
+            const weight = (file.linesAdded || 0) + (file.linesRemoved || 0) + ((file.changeCount || 1) * 5);
+            score.set(file.path, (score.get(file.path) || 0) + weight);
+        }
+    }
+    return [...score.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 8)
+        .map(([path]) => path);
+}
+function deriveCurrentPhase(runs) {
+    const tasks = runs.flatMap((run) => run.tasks || []);
+    if (tasks.some((task) => task.status === 'in-progress'))
+        return 'In Progress';
+    if (tasks.some((task) => task.status === 'pending'))
+        return 'Planned';
+    if (tasks.some((task) => task.status === 'done'))
+        return 'Completed';
+    return 'Not Started';
+}
+function inferModules(requirement, runs) {
+    if (requirement?.modules?.length) {
+        return uniqueStrings(requirement.modules.map((module) => module.name).filter(Boolean));
+    }
+    return uniqueStrings(runs
+        .flatMap((run) => run.tasks || [])
+        .map((task) => task.stageName)
+        .filter((stage) => stage && stage !== 'default'));
+}
+function renderListSection(title, values) {
+    if (values.length === 0)
+        return `## ${title}\n\n- None\n`;
+    return `## ${title}\n\n${values.map((value) => `- ${value}`).join('\n')}\n`;
+}
+function renderModuleMemoryCompact(record) {
+    const lines = [
+        `## Module: ${record.title}`,
+        '',
+        `- Key: ${record.moduleKey}`,
+        `- Updated At: ${record.updatedAt}`,
+        '',
+        record.summary || 'No summary yet.',
+        '',
+        renderListSection('Entry Files', record.entryFiles.slice(0, 6)).trimEnd(),
+        '',
+        renderListSection('Decisions', record.decisions.slice(0, 6)).trimEnd(),
+        '',
+        renderListSection('Constraints', record.constraints.slice(0, 6)).trimEnd(),
+        '',
+        renderListSection('Pitfalls', record.pitfalls.slice(0, 6)).trimEnd(),
+        '',
+    ];
+    return lines.join('\n').trimEnd();
+}
+function splitQueryTokens(query) {
+    return uniqueStrings(query
+        .toLowerCase()
+        .split(/[\s,/._-]+/)
+        .filter((item) => item.length > 1));
+}
+function scoreText(query, tokens, candidate) {
+    const text = candidate.toLowerCase();
+    let score = 0;
+    if (!candidate)
+        return score;
+    if (text.includes(query))
+        score += 8;
+    for (const token of tokens) {
+        if (text.includes(token))
+            score += 3;
+    }
+    return score;
+}
+export function normalizeModuleKey(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9/_\u4e00-\u9fa5-]+/g, '-')
+        .replace(/\/+/g, '/')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export function loadMemoryIndex(projectRoot) {
+    const path = memoryIndexPath(projectRoot);
+    if (!fileExists(path)) {
+        return {
+            updatedAt: new Date().toISOString(),
+            modules: [],
+        };
+    }
+    return readJson(path);
+}
+export function saveMemoryIndex(projectRoot, index) {
+    ensureDir(memoriesDir(projectRoot));
+    writeJson(memoryIndexPath(projectRoot), index);
+}
+export function loadModuleMemory(projectRoot, moduleKey) {
+    const normalized = normalizeModuleKey(moduleKey);
+    const path = moduleMemoryPath(projectRoot, normalized);
+    if (!fileExists(path))
+        return null;
+    return readJson(path);
+}
+function upsertMemoryIndexEntry(projectRoot, record) {
+    const index = loadMemoryIndex(projectRoot);
+    const entry = {
+        key: record.moduleKey,
+        title: record.title,
+        summary: record.summary,
+        keywords: topItems([record.moduleKey, record.title, ...record.keywords], 12),
+        paths: topItems([...record.entryFiles, ...record.relatedPaths], 12),
+        updatedAt: record.updatedAt,
+    };
+    const next = index.modules.filter((item) => item.key !== record.moduleKey);
+    next.push(entry);
+    next.sort((a, b) => a.key.localeCompare(b.key));
+    saveMemoryIndex(projectRoot, {
+        updatedAt: new Date().toISOString(),
+        modules: next,
+    });
+}
+export function saveModuleMemory(projectRoot, record) {
+    ensureDir(moduleMemoriesDir(projectRoot));
+    writeJson(moduleMemoryPath(projectRoot, record.moduleKey), record);
+    upsertMemoryIndexEntry(projectRoot, record);
+}
+export function loadRunContext(projectRoot, branchName) {
+    const path = runContextPath(projectRoot, branchName);
+    if (!fileExists(path))
+        return null;
+    return readJson(path);
+}
+export function saveRunContext(projectRoot, branchName, record) {
+    ensureDir(branchDir(projectRoot, branchName));
+    writeJson(runContextPath(projectRoot, branchName), record);
+}
+export function renderModuleMemoryMarkdown(record) {
+    const lines = [
+        '# Module Memory',
+        '',
+        `- Module Key: ${record.moduleKey}`,
+        `- Title: ${record.title}`,
+        `- Updated At: ${record.updatedAt}`,
+        '',
+        '## Summary',
+        '',
+        record.summary || 'No summary yet.',
+        '',
+        renderListSection('Keywords', record.keywords).trimEnd(),
+        '',
+        renderListSection('Entry Files', record.entryFiles).trimEnd(),
+        '',
+        renderListSection('Related Paths', record.relatedPaths).trimEnd(),
+        '',
+        renderListSection('Data Flow', record.dataFlow).trimEnd(),
+        '',
+        renderListSection('Decisions', record.decisions).trimEnd(),
+        '',
+        renderListSection('Constraints', record.constraints).trimEnd(),
+        '',
+        renderListSection('Pitfalls', record.pitfalls).trimEnd(),
+        '',
+        renderListSection('Related Rules', record.relatedRules).trimEnd(),
+        '',
+        '## Related Tickets',
+        '',
+        ...(record.tickets.length > 0
+            ? record.tickets.map((ticket) => `- ${[ticket.ticket, ticket.branch, ticket.summary].filter(Boolean).join(' | ')}`)
+            : ['- None']),
+        '',
+    ];
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export function renderRunContextMarkdown(record) {
+    const lines = [
+        '# Run Context',
+        '',
+        `- Branch: ${record.branch}`,
+        `- Title: ${record.title}`,
+        `- Ticket: ${record.ticket || '-'}`,
+        `- Current Phase: ${record.currentPhase}`,
+        `- Updated At: ${record.updatedAt}`,
+        '',
+        '## Summary',
+        '',
+        record.summary || 'No summary yet.',
+        '',
+        renderListSection('Modules', record.modules).trimEnd(),
+        '',
+        renderListSection('Completed', record.completed).trimEnd(),
+        '',
+        renderListSection('In Progress', record.inProgress).trimEnd(),
+        '',
+        renderListSection('Next', record.next).trimEnd(),
+        '',
+        renderListSection('Decisions', record.decisions).trimEnd(),
+        '',
+        renderListSection('Constraints', record.constraints).trimEnd(),
+        '',
+        renderListSection('Key Files', record.keyFiles).trimEnd(),
+        '',
+        renderListSection('Risks', record.risks).trimEnd(),
+        '',
+    ];
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export function renderRunMemoryPackMarkdown(context, modules) {
+    const lines = [
+        '# Runtime Memory Pack',
+        '',
+        '> This file is auto-generated from branch context and related module memories.',
+        '',
+        renderRunContextMarkdown(context).trimEnd(),
+    ];
+    if (modules.length > 0) {
+        lines.push('', '# Related Module Memories', '');
+        for (const module of modules) {
+            lines.push(renderModuleMemoryCompact(module), '');
+        }
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export function buildMemoryViews(projectRoot) {
+    ensureDir(moduleMemoriesDir(projectRoot));
+    let moduleViews = 0;
+    for (const file of walkJsonFiles(moduleMemoriesDir(projectRoot))) {
+        if (basename(file) === 'index.json')
+            continue;
+        const record = readJson(file);
+        writeText(moduleMemoryViewPath(projectRoot, record.moduleKey), renderModuleMemoryMarkdown(record));
+        moduleViews++;
+    }
+    let contextViews = 0;
+    let packViews = 0;
+    const root = runsDir(projectRoot);
+    if (!fileExists(root))
+        return { moduleViews, contextViews, packViews };
+    for (const branchName of readdirSync(root)) {
+        const safeBranchDir = resolve(root, branchName);
+        if (!fileExists(safeBranchDir) || !statSync(safeBranchDir).isDirectory())
+            continue;
+        const contextPath = resolve(safeBranchDir, 'context.json');
+        if (!fileExists(contextPath))
+            continue;
+        const record = readJson(contextPath);
+        writeText(runContextViewPath(projectRoot, record.branch), renderRunContextMarkdown(record));
+        contextViews++;
+        const modules = record.modules
+            .map((moduleName) => loadModuleMemory(projectRoot, moduleName))
+            .filter((item) => item !== null);
+        writeText(runMemoryPackViewPath(projectRoot, record.branch), renderRunMemoryPackMarkdown(record, modules));
+        packViews++;
+    }
+    return { moduleViews, contextViews, packViews };
+}
+export function buildRunContextFromBranch(projectRoot, branchName) {
+    const requirement = loadRequirement(projectRoot, branchName);
+    const analysis = loadAnalysis(projectRoot, branchName);
+    const runs = loadBranchRuns(projectRoot, branchName);
+    if (!requirement && !analysis && runs.length === 0) {
+        return null;
+    }
+    const modules = inferModules(requirement, runs);
+    const completed = topItems(runs.flatMap((run) => run.tasks || []).filter((task) => task.status === 'done').map((task) => task.title));
+    const inProgress = topItems(runs.flatMap((run) => run.tasks || []).filter((task) => task.status === 'in-progress').map((task) => task.title));
+    const next = topItems(runs.flatMap((run) => run.tasks || []).filter((task) => task.status === 'pending').map((task) => task.title));
+    const decisions = topItems(findSectionItems(analysis, ['决策', 'decision', '方案']));
+    const constraints = topItems(findSectionItems(analysis, ['约束', 'constraint', '限制']));
+    const analysisRisks = findSectionItems(analysis, ['风险', 'risk', '注意']);
+    const runRisks = [
+        ...runs.flatMap((run) => run.bugs || []).filter((bug) => bug.status !== 'fixed').map((bug) => bug.title),
+        ...runs.flatMap((run) => run.deviations || []).map((deviation) => deviation.title),
+    ];
+    const title = requirement?.title || extractTicket(branchName) || branchName;
+    return {
+        branch: branchName,
+        ticket: extractTicket(requirement?.title || '') || extractTicket(branchName),
+        title,
+        summary: requirement?.summary || extractSummaryFromAnalysis(analysis) || title,
+        currentPhase: deriveCurrentPhase(runs),
+        modules,
+        completed,
+        inProgress,
+        next,
+        decisions,
+        constraints,
+        keyFiles: pickKeyFiles(runs),
+        risks: topItems([...analysisRisks, ...runRisks]),
+        updatedAt: new Date().toISOString(),
+    };
+}
+function collectRelatedPaths(moduleName, branchContext, runs) {
+    const query = moduleName.toLowerCase();
+    const tokens = splitQueryTokens(query);
+    const scored = new Map();
+    for (const path of branchContext.keyFiles) {
+        const score = scoreText(query, tokens, path);
+        if (score > 0)
+            scored.set(path, score);
+    }
+    for (const run of runs) {
+        for (const task of run.tasks || []) {
+            if (task.stageName !== moduleName)
+                continue;
+            for (const file of run.files || []) {
+                const bonus = (file.linesAdded || 0) + (file.linesRemoved || 0) + 10;
+                scored.set(file.path, (scored.get(file.path) || 0) + bonus);
+            }
+        }
+    }
+    const ranked = [...scored.entries()].sort((a, b) => b[1] - a[1]).map(([path]) => path);
+    return ranked.length > 0 ? ranked.slice(0, 8) : branchContext.keyFiles.slice(0, 5);
+}
+export function upsertModuleMemory(projectRoot, input) {
+    const moduleKey = normalizeModuleKey(input.moduleKey);
+    const existing = loadModuleMemory(projectRoot, moduleKey);
+    const record = {
+        moduleKey,
+        title: input.title || existing?.title || moduleKey,
+        summary: input.summary || existing?.summary || '',
+        keywords: topItems([...(existing?.keywords || []), ...(input.keywords || []), moduleKey, input.title || ''], 16),
+        entryFiles: topItems([...(existing?.entryFiles || []), ...(input.entryFiles || [])]),
+        relatedPaths: topItems([...(existing?.relatedPaths || []), ...(input.relatedPaths || [])], 12),
+        dataFlow: topItems([...(existing?.dataFlow || []), ...(input.dataFlow || [])]),
+        decisions: topItems([...(existing?.decisions || []), ...(input.decisions || [])]),
+        constraints: topItems([...(existing?.constraints || []), ...(input.constraints || [])]),
+        pitfalls: topItems([...(existing?.pitfalls || []), ...(input.pitfalls || [])]),
+        relatedRules: topItems([...(existing?.relatedRules || []), ...(input.relatedRules || [])], 12),
+        tickets: [
+            ...(existing?.tickets || []),
+            ...((input.tickets || []).filter((ticket) => ticket.summary.trim().length > 0)),
+        ].filter((ticket, index, array) => array.findIndex((item) => item.ticket === ticket.ticket
+            && item.branch === ticket.branch
+            && item.summary === ticket.summary) === index),
+        updatedAt: new Date().toISOString(),
+    };
+    saveModuleMemory(projectRoot, record);
+    return record;
+}
+export function updateRunContext(projectRoot, input) {
+    const existing = loadRunContext(projectRoot, input.branch);
+    const record = {
+        branch: input.branch,
+        ticket: input.ticket ?? existing?.ticket,
+        title: input.title || existing?.title || input.branch,
+        summary: input.summary || existing?.summary || '',
+        currentPhase: input.currentPhase || existing?.currentPhase || 'Not Started',
+        modules: topItems([...(existing?.modules || []), ...(input.modules || [])], 12),
+        completed: topItems([...(existing?.completed || []), ...(input.completed || [])], 12),
+        inProgress: topItems([...(existing?.inProgress || []), ...(input.inProgress || [])], 12),
+        next: topItems([...(existing?.next || []), ...(input.next || [])], 12),
+        decisions: topItems([...(existing?.decisions || []), ...(input.decisions || [])], 12),
+        constraints: topItems([...(existing?.constraints || []), ...(input.constraints || [])], 12),
+        keyFiles: topItems([...(existing?.keyFiles || []), ...(input.keyFiles || [])], 12),
+        risks: topItems([...(existing?.risks || []), ...(input.risks || [])], 12),
+        updatedAt: new Date().toISOString(),
+    };
+    saveRunContext(projectRoot, input.branch, record);
+    return record;
+}
+export function searchModuleMemories(projectRoot, query, pathHints = []) {
+    const normalizedQuery = query.trim().toLowerCase();
+    if (!normalizedQuery)
+        return [];
+    const tokens = splitQueryTokens(normalizedQuery);
+    const hints = pathHints.map((hint) => hint.toLowerCase());
+    const index = loadMemoryIndex(projectRoot);
+    return index.modules
+        .map((entry) => {
+        let score = 0;
+        score += scoreText(normalizedQuery, tokens, entry.key) * 2;
+        score += scoreText(normalizedQuery, tokens, entry.title) * 2;
+        score += scoreText(normalizedQuery, tokens, entry.summary);
+        score += entry.keywords.reduce((sum, keyword) => sum + scoreText(normalizedQuery, tokens, keyword), 0);
+        score += entry.paths.reduce((sum, path) => sum + scoreText(normalizedQuery, tokens, path), 0);
+        for (const hint of hints) {
+            if (entry.paths.some((path) => path.toLowerCase().includes(hint)))
+                score += 10;
+        }
+        return { ...entry, score };
+    })
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.key.localeCompare(b.key))
+        .slice(0, 8);
+}
+export function migrateLegacyMemories(projectRoot) {
+    ensureDir(moduleMemoriesDir(projectRoot));
+    const branchesDir = runsDir(projectRoot);
+    if (!fileExists(branchesDir)) {
+        return { branches: 0, contextsWritten: 0, moduleMemoriesWritten: 0, modulesTouched: [] };
+    }
+    let branches = 0;
+    let contextsWritten = 0;
+    let moduleMemoriesWritten = 0;
+    const modulesTouched = new Set();
+    for (const safeBranch of readdirSync(branchesDir)) {
+        const branchPath = resolve(branchesDir, safeBranch);
+        if (!statSync(branchPath).isDirectory())
+            continue;
+        const requirement = fileExists(resolve(branchPath, 'requirement.json'));
+        const analysis = fileExists(resolve(branchPath, 'analysis.md'));
+        const runFiles = walkRunJsonFiles(branchesDir).filter((file) => file.includes(`/${safeBranch}/`));
+        if (!requirement && !analysis && runFiles.length === 0)
+            continue;
+        const requirementData = requirement
+            ? readJson(resolve(branchPath, 'requirement.json'))
+            : null;
+        const branchName = requirementData?.branch || safeBranch.replace(/-/g, '/');
+        const context = buildRunContextFromBranch(projectRoot, branchName);
+        if (!context)
+            continue;
+        branches++;
+        saveRunContext(projectRoot, branchName, context);
+        contextsWritten++;
+        const runs = loadBranchRuns(projectRoot, branchName);
+        const req = loadRequirement(projectRoot, branchName);
+        const moduleCandidates = req?.modules?.length
+            ? req.modules.map((module) => ({ name: module.name, description: module.description }))
+            : context.modules.map((name) => ({ name, description: '' }));
+        for (const candidate of moduleCandidates) {
+            if (!candidate.name.trim())
+                continue;
+            const moduleKey = normalizeModuleKey(candidate.name);
+            const relatedPaths = collectRelatedPaths(candidate.name, context, runs);
+            upsertModuleMemory(projectRoot, {
+                moduleKey,
+                title: candidate.name,
+                summary: candidate.description || context.summary,
+                keywords: [candidate.name, moduleKey, context.title],
+                entryFiles: relatedPaths.slice(0, 5),
+                relatedPaths,
+                decisions: context.decisions,
+                constraints: context.constraints,
+                pitfalls: context.risks,
+                tickets: [{
+                        ticket: context.ticket,
+                        branch: branchName,
+                        summary: context.summary,
+                        updatedAt: context.updatedAt,
+                    }],
+            });
+            moduleMemoriesWritten++;
+            modulesTouched.add(moduleKey);
+        }
+    }
+    buildMemoryViews(projectRoot);
+    return {
+        branches,
+        contextsWritten,
+        moduleMemoriesWritten,
+        modulesTouched: [...modulesTouched].sort(),
+    };
+}
+export function rebuildCurrentBranchMemory(projectRoot, branchName) {
+    const context = buildRunContextFromBranch(projectRoot, branchName);
+    if (!context) {
+        return { context: null, modules: [] };
+    }
+    saveRunContext(projectRoot, branchName, context);
+    const req = loadRequirement(projectRoot, branchName);
+    const runs = loadBranchRuns(projectRoot, branchName);
+    const modules = [];
+    for (const moduleName of inferModules(req, runs)) {
+        const relatedPaths = collectRelatedPaths(moduleName, context, runs);
+        modules.push(upsertModuleMemory(projectRoot, {
+            moduleKey: moduleName,
+            title: moduleName,
+            summary: req?.modules?.find((module) => module.name === moduleName)?.description || context.summary,
+            keywords: [moduleName, context.title],
+            entryFiles: relatedPaths.slice(0, 5),
+            relatedPaths,
+            decisions: context.decisions,
+            constraints: context.constraints,
+            pitfalls: context.risks,
+            tickets: [{
+                    ticket: context.ticket,
+                    branch: branchName,
+                    summary: context.summary,
+                    updatedAt: context.updatedAt,
+                }],
+        }));
+    }
+    buildMemoryViews(projectRoot);
+    return { context, modules };
+}
+export function loadRunMemoryPack(projectRoot, branchName) {
+    const context = loadRunContext(projectRoot, branchName);
+    if (!context)
+        return null;
+    const modules = context.modules
+        .map((moduleName) => loadModuleMemory(projectRoot, moduleName))
+        .filter((item) => item !== null);
+    return { context, modules };
+}
+//# sourceMappingURL=memory.js.map