ai-dev-analytics 2.0.0 → 2.0.1

package/dist/cli/commands/merge-data.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"merge-data.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/merge-data.ts"],"names":[],"mappings":"AAuDA,KAAK,WAAW,GAAG,QAAQ,GAAG,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC;AAElE,UAAU,gBAAgB;IACxB,MAAM,EAAE,WAAW,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf;AA+iBD,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,gBAAgB,CAAA;IAC7B,cAAc,EAAE,gBAAgB,CAAA;IAChC,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,YAAY,EAAE,gBAAgB,CAAA;IAC9B,IAAI,EAAE,gBAAgB,CAAA;IACtB,YAAY,EAAE,OAAO,CAAA;IACrB,kBAAkB,EAAE,OAAO,CAAA;CAC5B;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,gBAAgB,CAqEvE;AAcD,wBAAsB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CA2C/C"}

package/dist/cli/commands/merge-data.js

@@ -1,634 +0,0 @@
-import { readdirSync, statSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { green, red, yellow } from '../../utils/display.js';
-import { fileExists, readText, extractConflictSections, writeJson, } from '../../utils/fs.js';
-import { aidaDir, configPath, legacyModuleMemoryPath, memoryIndexPath, moduleMemoriesDir, moduleMemoryPath, runsDir, } from '../../utils/paths.js';
-import { buildMemoryViews, loadMemoryIndex, loadModuleMemory, normalizeModuleKey, saveModuleMemory, } from '../../utils/memory.js';
-import { buildIndex } from './reindex.js';
-import { normalizeRunData, recalcMetrics, resolveCurrentTaskId } from '../../utils/run-data.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 latestIso(a, b) {
-    if (!a)
-        return b || '';
-    if (!b)
-        return a;
-    return new Date(a).getTime() >= new Date(b).getTime() ? a : b;
-}
-function pickLatestString(current, incoming, currentUpdatedAt, incomingUpdatedAt) {
-    const currentValue = (current || '').trim();
-    const incomingValue = (incoming || '').trim();
-    if (!currentValue)
-        return incomingValue;
-    if (!incomingValue)
-        return currentValue;
-    return latestIso(currentUpdatedAt, incomingUpdatedAt) === incomingUpdatedAt ? incomingValue : currentValue;
-}
-function parseConflictJsonObject(raw) {
-    const trimmed = raw.trim();
-    if (!trimmed || trimmed === 'null')
-        return null;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-}
-function hasConflict(filePath) {
-    if (!fileExists(filePath))
-        return false;
-    const raw = readText(filePath);
-    return raw.includes('<<<<<<<') || raw.includes('>>>>>>>');
-}
-function mergeByKey(items, keyOf, mergeItem) {
-    const map = new Map();
-    for (const item of items) {
-        const key = keyOf(item);
-        const existing = map.get(key);
-        map.set(key, existing ? mergeItem(existing, item) : item);
-    }
-    return [...map.values()];
-}
-function mergeIndexEntry(current, incoming) {
-    const useIncoming = latestIso(current.updatedAt, incoming.updatedAt) === incoming.updatedAt;
-    return {
-        key: current.key || incoming.key,
-        title: pickLatestString(current.title, incoming.title, current.updatedAt, incoming.updatedAt),
-        summary: pickLatestString(current.summary, incoming.summary, current.updatedAt, incoming.updatedAt),
-        keywords: uniqueStrings([...current.keywords, ...incoming.keywords]),
-        paths: uniqueStrings([...current.paths, ...incoming.paths]),
-        tickets: uniqueStrings([...(current.tickets || []), ...(incoming.tickets || [])]),
-        updatedAt: useIncoming ? incoming.updatedAt : current.updatedAt,
-    };
-}
-function mergeMemoryIndex(ours, theirs) {
-    const mergedModules = mergeByKey([...((ours?.items || ours?.modules || [])), ...((theirs?.items || theirs?.modules || []))], (item) => normalizeModuleKey(item.key), (current, incoming) => mergeIndexEntry({ ...current, key: normalizeModuleKey(current.key) }, { ...incoming, key: normalizeModuleKey(incoming.key) })).sort((a, b) => a.key.localeCompare(b.key));
-    return {
-        schemaVersion: '2.0',
-        updatedAt: latestIso(ours?.updatedAt, theirs?.updatedAt),
-        items: mergedModules,
-    };
-}
-function hydrateModuleMemoryFromIndex(projectRoot, entry) {
-    const moduleKey = normalizeModuleKey(entry.key);
-    if (!moduleKey)
-        return;
-    const existing = loadModuleMemory(projectRoot, moduleKey);
-    if (existing) {
-        saveModuleMemory(projectRoot, {
-            ...existing,
-            moduleKey,
-            title: existing.title || entry.title || moduleKey,
-            summary: existing.summary || entry.summary || '',
-            keywords: uniqueStrings([...(existing.keywords || []), moduleKey, entry.title, ...(entry.keywords || [])]),
-            entryFiles: uniqueStrings([...(existing.entryFiles || []), ...(entry.paths || [])]),
-            relatedPaths: uniqueStrings([...(existing.relatedPaths || []), ...(entry.paths || [])]),
-            updatedAt: latestIso(existing.updatedAt, entry.updatedAt) || existing.updatedAt || entry.updatedAt || new Date().toISOString(),
-        });
-        return;
-    }
-    if (fileExists(moduleMemoryPath(projectRoot, moduleKey)))
-        return;
-    if (fileExists(legacyModuleMemoryPath(projectRoot, moduleKey)))
-        return;
-    saveModuleMemory(projectRoot, {
-        schemaVersion: '2.0',
-        moduleKey,
-        title: entry.title || moduleKey,
-        summary: entry.summary || '',
-        keywords: uniqueStrings([moduleKey, entry.title, ...(entry.keywords || [])]),
-        entryFiles: uniqueStrings(entry.paths || []),
-        relatedPaths: uniqueStrings(entry.paths || []),
-        dataFlow: [],
-        decisions: [],
-        constraints: [],
-        pitfalls: [],
-        relatedRules: [],
-        tickets: [],
-        changes: [],
-        updatedAt: entry.updatedAt || new Date().toISOString(),
-    });
-}
-function hydrateMissingModuleMemoriesFromIndex(projectRoot) {
-    const index = loadMemoryIndex(projectRoot);
-    for (const entry of index.items) {
-        hydrateModuleMemoryFromIndex(projectRoot, entry);
-    }
-}
-function mergeModuleMemoryRecord(current, incoming) {
-    const useIncoming = latestIso(current.updatedAt, incoming.updatedAt) === incoming.updatedAt;
-    const mergedTickets = mergeByKey([...current.tickets, ...incoming.tickets], (item) => `${item.ticket || ''}|${item.branch || ''}`, (left, right) => ({
-        ticket: left.ticket || right.ticket,
-        branch: left.branch || right.branch,
-        summary: pickLatestString(left.summary, right.summary, left.updatedAt, right.updatedAt),
-        updatedAt: latestIso(left.updatedAt, right.updatedAt),
-    }));
-    const mergedChanges = mergeByKey([...(current.changes || []), ...(incoming.changes || [])], (item) => item.ticket || item.branch
-        ? `${item.ticket || ''}|${item.branch || ''}`
-        : `${item.title || ''}|${item.summary}`, (left, right) => ({
-        ticket: left.ticket || right.ticket,
-        branch: left.branch || right.branch,
-        title: pickLatestString(left.title, right.title, left.updatedAt, right.updatedAt) || undefined,
-        summary: pickLatestString(left.summary, right.summary, left.updatedAt, right.updatedAt),
-        updatedAt: latestIso(left.updatedAt, right.updatedAt),
-    }));
-    return {
-        schemaVersion: '2.0',
-        moduleKey: current.moduleKey || incoming.moduleKey,
-        title: pickLatestString(current.title, incoming.title, current.updatedAt, incoming.updatedAt),
-        summary: pickLatestString(current.summary, incoming.summary, current.updatedAt, incoming.updatedAt),
-        keywords: uniqueStrings([...current.keywords, ...incoming.keywords]),
-        entryFiles: uniqueStrings([...current.entryFiles, ...incoming.entryFiles]),
-        relatedPaths: uniqueStrings([...current.relatedPaths, ...incoming.relatedPaths]),
-        dataFlow: uniqueStrings([...current.dataFlow, ...incoming.dataFlow]),
-        decisions: uniqueStrings([...current.decisions, ...incoming.decisions]),
-        constraints: uniqueStrings([...current.constraints, ...incoming.constraints]),
-        pitfalls: uniqueStrings([...current.pitfalls, ...incoming.pitfalls]),
-        relatedRules: uniqueStrings([...current.relatedRules, ...incoming.relatedRules]),
-        tickets: mergedTickets,
-        changes: mergedChanges,
-        updatedAt: useIncoming ? incoming.updatedAt : current.updatedAt,
-    };
-}
-function mergeRunContextRecord(current, incoming) {
-    const useIncoming = latestIso(current.updatedAt, incoming.updatedAt) === incoming.updatedAt;
-    return {
-        branch: current.branch || incoming.branch,
-        ticket: pickLatestString(current.ticket, incoming.ticket, current.updatedAt, incoming.updatedAt) || undefined,
-        title: pickLatestString(current.title, incoming.title, current.updatedAt, incoming.updatedAt),
-        summary: pickLatestString(current.summary, incoming.summary, current.updatedAt, incoming.updatedAt),
-        currentPhase: pickLatestString(current.currentPhase, incoming.currentPhase, current.updatedAt, incoming.updatedAt),
-        modules: uniqueStrings([...current.modules, ...incoming.modules]),
-        completed: uniqueStrings([...current.completed, ...incoming.completed]),
-        inProgress: uniqueStrings([...current.inProgress, ...incoming.inProgress]),
-        next: uniqueStrings([...current.next, ...incoming.next]),
-        decisions: uniqueStrings([...current.decisions, ...incoming.decisions]),
-        constraints: uniqueStrings([...current.constraints, ...incoming.constraints]),
-        keyFiles: uniqueStrings([...current.keyFiles, ...incoming.keyFiles]),
-        risks: uniqueStrings([...current.risks, ...incoming.risks]),
-        updatedAt: useIncoming ? incoming.updatedAt : current.updatedAt,
-    };
-}
-function mergeRequirementModule(current, incoming) {
-    return {
-        id: current.id || incoming.id,
-        name: pickLatestString(current.name, incoming.name),
-        description: pickLatestString(current.description, incoming.description),
-        assignee: incoming.assignee || current.assignee,
-    };
-}
-function mergeRequirementPhase(current, incoming) {
-    return {
-        phase: current.phase || incoming.phase,
-        file: current.file || incoming.file,
-        title: pickLatestString(current.title, incoming.title),
-        confirmedAt: latestIso(current.confirmedAt || undefined, incoming.confirmedAt || undefined) || null,
-    };
-}
-function mergeDeveloper(current, incoming) {
-    return {
-        name: current.name || incoming.name,
-        modules: uniqueStrings([...current.modules, ...incoming.modules]),
-        tasks: Math.max(current.tasks, incoming.tasks),
-        completedTasks: Math.max(current.completedTasks, incoming.completedTasks),
-        bugs: Math.max(current.bugs, incoming.bugs),
-        deviations: Math.max(current.deviations, incoming.deviations),
-        linesAdded: Math.max(current.linesAdded, incoming.linesAdded),
-        linesRemoved: Math.max(current.linesRemoved, incoming.linesRemoved),
-        firstPassRate: Math.max(current.firstPassRate, incoming.firstPassRate),
-        actualWorkSeconds: Math.max(current.actualWorkSeconds, incoming.actualWorkSeconds),
-        totalTokens: Math.max(current.totalTokens, incoming.totalTokens),
-    };
-}
-function mergeRequirementRecord(current, incoming) {
-    const developers = mergeByKey([...current.developers, ...incoming.developers], (item) => item.name, mergeDeveloper).sort((a, b) => a.name.localeCompare(b.name));
-    const modules = mergeByKey([...current.modules, ...incoming.modules], (item) => item.id || item.name, mergeRequirementModule);
-    const prdPhases = mergeByKey([...current.prdPhases, ...incoming.prdPhases], (item) => `${item.phase}|${item.file}`, mergeRequirementPhase);
-    const highlights = mergeByKey([...current.highlights, ...incoming.highlights], (item) => `${item.content}|${item.createdAt}`, (left) => left);
-    return {
-        branch: current.branch || incoming.branch,
-        title: pickLatestString(current.title, incoming.title, current.updatedAt, incoming.updatedAt),
-        summary: pickLatestString(current.summary, incoming.summary, current.updatedAt, incoming.updatedAt),
-        prdPhases,
-        modules,
-        highlights,
-        developers,
-        totals: {
-            tasks: developers.reduce((sum, item) => sum + item.tasks, 0),
-            completedTasks: developers.reduce((sum, item) => sum + item.completedTasks, 0),
-            bugs: developers.reduce((sum, item) => sum + item.bugs, 0),
-            deviations: developers.reduce((sum, item) => sum + item.deviations, 0),
-            linesAdded: developers.reduce((sum, item) => sum + item.linesAdded, 0),
-            linesRemoved: developers.reduce((sum, item) => sum + item.linesRemoved, 0),
-            totalTokens: developers.reduce((sum, item) => sum + item.totalTokens, 0),
-        },
-        createdAt: current.createdAt || incoming.createdAt,
-        updatedAt: latestIso(current.updatedAt, incoming.updatedAt),
-    };
-}
-const taskStatusRank = {
-    pending: 0,
-    'in-progress': 1,
-    done: 2,
-};
-function mergeTask(current, incoming) {
-    const currentRank = taskStatusRank[current.status];
-    const incomingRank = taskStatusRank[incoming.status];
-    const preferred = incomingRank >= currentRank ? incoming : current;
-    const other = preferred === incoming ? current : incoming;
-    return {
-        ...preferred,
-        title: pickLatestString(current.title, incoming.title),
-        stageName: pickLatestString(current.stageName, incoming.stageName),
-        prdPhase: pickLatestString(current.prdPhase, incoming.prdPhase),
-        acceptance: pickLatestString(current.acceptance, incoming.acceptance) || undefined,
-        createdAt: current.createdAt || incoming.createdAt,
-        startedAt: latestIso(current.startedAt, incoming.startedAt) || current.startedAt || incoming.startedAt,
-        completedAt: latestIso(current.completedAt || undefined, incoming.completedAt || undefined) || preferred.completedAt || other.completedAt || null,
-        status: currentRank === incomingRank ? preferred.status : (incomingRank > currentRank ? incoming.status : current.status),
-    };
-}
-function mergeBug(current, incoming) {
-    const status = current.status === 'fixed' || incoming.status === 'fixed' ? 'fixed' : 'open';
-    const severityOrder = { low: 0, medium: 1, high: 2, critical: 3 };
-    return {
-        ...current,
-        ...incoming,
-        title: pickLatestString(current.title, incoming.title),
-        severity: severityOrder[current.severity] >= severityOrder[incoming.severity] ? current.severity : incoming.severity,
-        source: current.source || incoming.source,
-        status,
-        files: uniqueStrings([...current.files, ...incoming.files]),
-        fix: pickLatestString(current.fix || undefined, incoming.fix || undefined) || null,
-        taskId: incoming.taskId || current.taskId || null,
-        reportedAt: current.reportedAt || incoming.reportedAt,
-        fixedAt: latestIso(current.fixedAt || undefined, incoming.fixedAt || undefined) || null,
-    };
-}
-function mergeDeviation(current, incoming) {
-    return {
-        ...current,
-        ...incoming,
-        title: pickLatestString(current.title, incoming.title),
-        aiOutput: pickLatestString(current.aiOutput, incoming.aiOutput) || undefined,
-        expectedOutput: pickLatestString(current.expectedOutput, incoming.expectedOutput) || undefined,
-        files: uniqueStrings([...current.files, ...incoming.files]),
-        ruleSedimented: incoming.ruleSedimented ?? current.ruleSedimented,
-        detectedAt: current.detectedAt || incoming.detectedAt,
-        fixedAt: latestIso(current.fixedAt || undefined, incoming.fixedAt || undefined) || null,
-    };
-}
-function mergeReview(current, incoming) {
-    const preferred = latestIso(current.reviewedAt, incoming.reviewedAt) === incoming.reviewedAt ? incoming : current;
-    return {
-        ...preferred,
-        taskId: incoming.taskId || current.taskId || null,
-        scope: pickLatestString(current.scope, incoming.scope),
-        result: preferred.result,
-        issueCount: Math.max(current.issueCount, incoming.issueCount),
-        issues: uniqueStrings([...(current.issues || []), ...(incoming.issues || [])]),
-        reviewedAt: preferred.reviewedAt,
-    };
-}
-function mergeRuleItem(current, incoming) {
-    const preferred = latestIso(current.sedimentedAt || undefined, incoming.sedimentedAt || undefined) === incoming.sedimentedAt ? incoming : current;
-    return {
-        ...preferred,
-        content: pickLatestString(current.content, incoming.content),
-        category: pickLatestString(current.category, incoming.category) || undefined,
-        sourceDeviation: incoming.sourceDeviation || current.sourceDeviation || null,
-        sedimentedAt: latestIso(current.sedimentedAt || undefined, incoming.sedimentedAt || undefined) || null,
-        file: pickLatestString(current.file, incoming.file),
-        status: incoming.status || current.status,
-    };
-}
-function mergeFileItem(current, incoming) {
-    const changeType = current.changeType === incoming.changeType
-        ? current.changeType
-        : (current.changeType === 'deleted' || incoming.changeType === 'deleted' ? 'deleted' : 'modified');
-    return {
-        path: current.path || incoming.path,
-        changeType,
-        linesAdded: Math.max(current.linesAdded, incoming.linesAdded),
-        linesRemoved: Math.max(current.linesRemoved, incoming.linesRemoved),
-        changeCount: Math.max(current.changeCount, incoming.changeCount),
-        lastModified: latestIso(current.lastModified, incoming.lastModified) || undefined,
-    };
-}
-function mergeWorkflow(current, incoming) {
-    const statusRank = {
-        pending: 0,
-        in_progress: 1,
-        completed: 2,
-        failed: 3,
-    };
-    const preferred = statusRank[incoming.status] >= statusRank[current.status] ? incoming : current;
-    return {
-        ...preferred,
-        stage: pickLatestString(current.stage, incoming.stage),
-        prdPhase: pickLatestString(current.prdPhase, incoming.prdPhase) || undefined,
-        startTime: current.startTime || incoming.startTime,
-        endTime: latestIso(current.endTime, incoming.endTime) || undefined,
-    };
-}
-function recalcRunSummary(data) {
-    data.summary.totalTasks = data.tasks.length;
-    data.summary.completedTasks = data.tasks.filter((item) => item.status === 'done').length;
-    data.summary.bugCount = data.bugs.length;
-    data.summary.deviationCount = data.deviations.length;
-    data.summary.reviewCount = data.reviews.length;
-    data.summary.reviewPassCount = data.reviews.filter((item) => item.result === 'pass').length;
-    data.summary.reviewFailCount = data.reviews.filter((item) => item.result === 'fail').length;
-    data.summary.rulesSedimented = data.rules.filter((item) => item.status !== 'pending').length;
-    data.summary.prdPhaseCount = uniqueStrings(data.tasks.map((item) => item.prdPhase)).length;
-    data.summary.filesChanged = data.files.length;
-    data.summary.linesAdded = data.files.reduce((sum, item) => sum + (item.linesAdded || 0), 0);
-    data.summary.linesRemoved = data.files.reduce((sum, item) => sum + (item.linesRemoved || 0), 0);
-}
-function mergeRunDataRecord(currentRaw, incomingRaw) {
-    const current = normalizeRunData(currentRaw);
-    const incoming = normalizeRunData(incomingRaw);
-    const merged = normalizeRunData({
-        ...current,
-        ...incoming,
-        meta: {
-            ...current.meta,
-            ...incoming.meta,
-            schemaVersion: incoming.meta.schemaVersion || current.meta.schemaVersion,
-            branch: current.meta.branch || incoming.meta.branch,
-            developer: current.meta.developer || incoming.meta.developer,
-            project: pickLatestString(current.meta.project, incoming.meta.project),
-            aiModel: pickLatestString(current.meta.aiModel, incoming.meta.aiModel),
-            aiTool: pickLatestString(current.meta.aiTool, incoming.meta.aiTool),
-            startTime: current.meta.startTime || incoming.meta.startTime,
-            endTime: latestIso(current.meta.endTime, incoming.meta.endTime) || undefined,
-            status: pickLatestString(current.meta.status, incoming.meta.status),
-            prdPhases: uniqueStrings([...(current.meta.prdPhases || []), ...(incoming.meta.prdPhases || [])]),
-        },
-        summary: { ...current.summary, ...incoming.summary },
-        metrics: { ...current.metrics, ...incoming.metrics },
-        context: {
-            ...current.context,
-            ...incoming.context,
-            currentStage: pickLatestString(current.context.currentStage, incoming.context.currentStage) || undefined,
-            currentPrdPhase: pickLatestString(current.context.currentPrdPhase, incoming.context.currentPrdPhase) || undefined,
-            currentTaskId: undefined,
-            lastUpdated: latestIso(current.context.lastUpdated, incoming.context.lastUpdated) || undefined,
-        },
-        tasks: mergeByKey([...current.tasks, ...incoming.tasks], (item) => item.taskId, mergeTask),
-        bugs: mergeByKey([...current.bugs, ...incoming.bugs], (item) => item.bugId, mergeBug),
-        deviations: mergeByKey([...current.deviations, ...incoming.deviations], (item) => item.deviationId, mergeDeviation),
-        reviews: mergeByKey([...current.reviews, ...incoming.reviews], (item) => item.reviewId, mergeReview),
-        rules: mergeByKey([...current.rules, ...incoming.rules], (item) => item.ruleId, mergeRuleItem),
-        files: mergeByKey([...current.files, ...incoming.files], (item) => item.path, mergeFileItem),
-        timeline: mergeByKey([...current.timeline, ...incoming.timeline], (item) => `${item.type}|${item.title}|${item.timestamp}`, (left) => left)
-            .sort((a, b) => a.timestamp.localeCompare(b.timestamp)),
-        workflow: mergeByKey([...current.workflow, ...incoming.workflow], (item) => `${item.stage}|${item.prdPhase || ''}`, mergeWorkflow),
-        events: mergeByKey([...current.events, ...incoming.events], (item) => `${item.type}|${item.time}|${JSON.stringify(item.data)}`, (left) => left)
-            .sort((a, b) => a.time.localeCompare(b.time)),
-        cost: {
-            ...current.cost,
-            ...incoming.cost,
-            totalTokens: Math.max(current.cost.totalTokens || 0, incoming.cost.totalTokens || 0),
-            estimatedManualHours: Math.max(current.cost.estimatedManualHours || 0, incoming.cost.estimatedManualHours || 0),
-            actualHours: Math.max(current.cost.actualHours || 0, incoming.cost.actualHours || 0),
-            tokenBreakdown: mergeByKey([...(current.cost.tokenBreakdown || []), ...(incoming.cost.tokenBreakdown || [])], (item) => item.stage, (left, right) => ({ stage: left.stage || right.stage, tokens: Math.max(left.tokens, right.tokens) })),
-            tokenDetail: current.cost.tokenDetail || incoming.cost.tokenDetail
-                ? {
-                    inputTokens: Math.max(current.cost.tokenDetail?.inputTokens || 0, incoming.cost.tokenDetail?.inputTokens || 0),
-                    outputTokens: Math.max(current.cost.tokenDetail?.outputTokens || 0, incoming.cost.tokenDetail?.outputTokens || 0),
-                    cacheCreationTokens: Math.max(current.cost.tokenDetail?.cacheCreationTokens || 0, incoming.cost.tokenDetail?.cacheCreationTokens || 0),
-                    cacheReadTokens: Math.max(current.cost.tokenDetail?.cacheReadTokens || 0, incoming.cost.tokenDetail?.cacheReadTokens || 0),
-                }
-                : undefined,
-        },
-        highlights: mergeByKey([...current.highlights, ...incoming.highlights], (item) => `${item.content}|${item.createdAt}`, (left) => left),
-    });
-    recalcRunSummary(merged);
-    merged.context.currentTaskId = resolveCurrentTaskId(merged.tasks);
-    const activeTask = merged.tasks.find((item) => item.taskId === merged.context.currentTaskId);
-    merged.context.currentStage = activeTask?.stageName;
-    merged.context.currentPrdPhase = activeTask?.prdPhase;
-    recalcMetrics(merged);
-    return merged;
-}
-function mergeConflictFile(filePath, mergeObjects) {
-    if (!fileExists(filePath))
-        return 'missing';
-    const raw = readText(filePath);
-    if (!raw.includes('<<<<<<<') && !raw.includes('>>>>>>>'))
-        return 'no-conflict';
-    const sections = extractConflictSections(raw);
-    if (!sections)
-        return 'error';
-    const ours = parseConflictJsonObject(sections.ours);
-    const theirs = parseConflictJsonObject(sections.theirs);
-    const merged = mergeObjects(ours, theirs);
-    writeJson(filePath, merged);
-    return 'merged';
-}
-function walkJsonTargets(rootDir, targetName) {
-    if (!fileExists(rootDir))
-        return [];
-    const results = [];
-    const stack = [rootDir];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        for (const name of readdirSync(current)) {
-            const fullPath = resolve(current, name);
-            const stat = statSync(fullPath);
-            if (stat.isDirectory())
-                stack.push(fullPath);
-            else if (name === targetName)
-                results.push(fullPath);
-        }
-    }
-    return results.sort();
-}
-function walkMemoryModuleFiles(rootDir) {
-    if (!fileExists(rootDir))
-        return [];
-    const results = [];
-    const stack = [rootDir];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        for (const name of readdirSync(current)) {
-            const fullPath = resolve(current, name);
-            const stat = statSync(fullPath);
-            if (stat.isDirectory())
-                stack.push(fullPath);
-            else if (name.endsWith('.json'))
-                results.push(fullPath);
-        }
-    }
-    return results.sort();
-}
-function mergeFixedFile(filePath, merger, counters) {
-    const status = mergeConflictFile(filePath, merger);
-    if (status === 'merged')
-        counters.merged++;
-    else if (status === 'missing')
-        counters.missing++;
-    else if (status === 'error')
-        counters.errors++;
-}
-function mergeModuleFiles(files, merger) {
-    const counters = { status: 'no-conflict', merged: 0, missing: 0, errors: 0 };
-    for (const filePath of files) {
-        if (!hasConflict(filePath))
-            continue;
-        const status = mergeConflictFile(filePath, (ours, theirs) => merger(ours, theirs));
-        if (status === 'merged')
-            counters.merged++;
-        else if (status === 'error')
-            counters.errors++;
-    }
-    counters.status = counters.errors > 0 ? 'error' : counters.merged > 0 ? 'merged' : 'no-conflict';
-    return counters;
-}
-function mergeRunFiles(files) {
-    const counters = { status: 'no-conflict', merged: 0, missing: 0, errors: 0 };
-    for (const filePath of files) {
-        if (!hasConflict(filePath))
-            continue;
-        const status = mergeConflictFile(filePath, (ours, theirs) => mergeRunDataRecord(ours, theirs));
-        if (status === 'merged')
-            counters.merged++;
-        else if (status === 'error')
-            counters.errors++;
-    }
-    counters.status = counters.errors > 0 ? 'error' : counters.merged > 0 ? 'merged' : 'no-conflict';
-    return counters;
-}
-export function mergeAidaJsonData(projectRoot) {
-    const summary = {
-        memoryIndex: { status: 'missing', merged: 0, missing: 1, errors: 0 },
-        moduleMemories: { status: 'missing', merged: 0, missing: 0, errors: 0 },
-        contexts: { status: 'missing', merged: 0, missing: 0, errors: 0 },
-        requirements: { status: 'missing', merged: 0, missing: 0, errors: 0 },
-        runs: { status: 'missing', merged: 0, missing: 0, errors: 0 },
-        rebuiltIndex: false,
-        rebuiltMemoryViews: false,
-    };
-    if (!fileExists(configPath(projectRoot)) || !fileExists(aidaDir(projectRoot))) {
-        return summary;
-    }
-    const memoryIndex = memoryIndexPath(projectRoot);
-    if (fileExists(memoryIndex)) {
-        summary.memoryIndex = { status: 'no-conflict', merged: 0, missing: 0, errors: 0 };
-        mergeFixedFile(memoryIndex, mergeMemoryIndex, summary.memoryIndex);
-        summary.memoryIndex.status = summary.memoryIndex.errors > 0 ? 'error' : summary.memoryIndex.merged > 0 ? 'merged' : 'no-conflict';
-    }
-    const moduleFiles = walkMemoryModuleFiles(moduleMemoriesDir(projectRoot));
-    summary.moduleMemories = moduleFiles.length === 0
-        ? { status: 'missing', merged: 0, missing: 0, errors: 0 }
-        : mergeModuleFiles(moduleFiles, mergeModuleMemoryRecord);
-    const contextFiles = walkJsonTargets(runsDir(projectRoot), 'context.json');
-    summary.contexts = { status: contextFiles.length === 0 ? 'missing' : 'no-conflict', merged: 0, missing: 0, errors: 0 };
-    for (const filePath of contextFiles) {
-        const status = mergeConflictFile(filePath, (ours, theirs) => mergeRunContextRecord(ours, theirs));
-        if (status === 'merged')
-            summary.contexts.merged++;
-        else if (status === 'error')
-            summary.contexts.errors++;
-    }
-    if (summary.contexts.status !== 'missing') {
-        summary.contexts.status = summary.contexts.errors > 0 ? 'error' : summary.contexts.merged > 0 ? 'merged' : 'no-conflict';
-    }
-    const requirementFiles = walkJsonTargets(runsDir(projectRoot), 'requirement.json');
-    summary.requirements = { status: requirementFiles.length === 0 ? 'missing' : 'no-conflict', merged: 0, missing: 0, errors: 0 };
-    for (const filePath of requirementFiles) {
-        const status = mergeConflictFile(filePath, (ours, theirs) => mergeRequirementRecord(ours, theirs));
-        if (status === 'merged')
-            summary.requirements.merged++;
-        else if (status === 'error')
-            summary.requirements.errors++;
-    }
-    if (summary.requirements.status !== 'missing') {
-        summary.requirements.status = summary.requirements.errors > 0 ? 'error' : summary.requirements.merged > 0 ? 'merged' : 'no-conflict';
-    }
-    const runFiles = walkJsonTargets(runsDir(projectRoot), 'run.json');
-    summary.runs = runFiles.length === 0 ? { status: 'missing', merged: 0, missing: 0, errors: 0 } : mergeRunFiles(runFiles);
-    const hasAnyMerge = [
-        summary.memoryIndex,
-        summary.moduleMemories,
-        summary.contexts,
-        summary.requirements,
-        summary.runs,
-    ].some((item) => item.status === 'merged');
-    if (hasAnyMerge) {
-        hydrateMissingModuleMemoriesFromIndex(projectRoot);
-        buildMemoryViews(projectRoot);
-        summary.rebuiltMemoryViews = true;
-        buildIndex(projectRoot);
-        summary.rebuiltIndex = true;
-    }
-    return summary;
-}
-function printLine(label, result) {
-    if (result.status === 'merged') {
-        console.log(`  ${label}: merged, ${result.merged} file(s)`);
-    }
-    else if (result.status === 'no-conflict') {
-        console.log(`  ${label}: no conflict`);
-    }
-    else if (result.status === 'missing') {
-        console.log(`  ${label}: missing`);
-    }
-    else {
-        console.log(`  ${label}: parse error`);
-    }
-}
-export async function mergeData() {
-    const projectRoot = process.cwd();
-    if (!fileExists(configPath(projectRoot))) {
-        console.log(red('\n  AIDA not initialized. Run `npx aida init` first.\n'));
-        return;
-    }
-    const summary = mergeAidaJsonData(projectRoot);
-    const hasError = [
-        summary.memoryIndex,
-        summary.moduleMemories,
-        summary.contexts,
-        summary.requirements,
-        summary.runs,
-    ].some((item) => item.status === 'error');
-    if (hasError) {
-        console.log(red('\n  AIDA data merge finished with parse errors. Resolve the remaining conflicted JSON manually.\n'));
-        return;
-    }
-    const changed = [
-        summary.memoryIndex,
-        summary.moduleMemories,
-        summary.contexts,
-        summary.requirements,
-        summary.runs,
-    ].some((item) => item.status === 'merged');
-    if (!changed) {
-        console.log(yellow('\n  No AIDA JSON conflicts detected.\n'));
-        return;
-    }
-    console.log(green('\n  ✓ AIDA data merge completed\n'));
-    printLine('memory index', summary.memoryIndex);
-    printLine('module memories', summary.moduleMemories);
-    printLine('branch contexts', summary.contexts);
-    printLine('requirements', summary.requirements);
-    printLine('run.json', summary.runs);
-    if (summary.rebuiltMemoryViews)
-        console.log('  memory views: rebuilt');
-    if (summary.rebuiltIndex)
-        console.log('  project index: rebuilt');
-    console.log('');
-}
-//# sourceMappingURL=merge-data.js.map