1413 lines
45 KiB
TypeScript
1413 lines
45 KiB
TypeScript
import { createHash } from 'crypto';
|
|
import { diffLines } from 'diff';
|
|
import { open, readFile } from 'fs/promises';
|
|
import * as path from 'path';
|
|
|
|
import { normalizePathForComparison } from '@shared/utils/platformPath';
|
|
import { createLogger } from '@shared/utils/logger';
|
|
|
|
import type {
|
|
FileChangeSummary,
|
|
FileEditEvent,
|
|
FileEditTimeline,
|
|
LedgerChangeRelation,
|
|
LedgerContentState,
|
|
SnippetDiff,
|
|
TaskChangeJournalStamp,
|
|
TaskChangeProvenance,
|
|
TaskChangeScope,
|
|
TaskChangeSetV2,
|
|
} from '@shared/types';
|
|
|
|
const logger = createLogger('Service:TaskChangeLedgerReader');
|
|
|
|
const TASK_CHANGE_JOURNAL_SCHEMA_VERSION = 1;
|
|
const TASK_CHANGE_SUMMARY_SCHEMA_VERSION = 2;
|
|
const TASK_CHANGE_FRESHNESS_SCHEMA_VERSION = 2;
|
|
const TASK_CHANGE_LEDGER_DIRNAME = '.board-task-changes';
|
|
const TASK_CHANGE_FRESHNESS_DIRNAME = '.board-task-change-freshness';
|
|
const MAX_TASK_ID_ARTIFACT_SEGMENT_LENGTH = 120;
|
|
|
|
function isWindowsReservedArtifactSegment(segment: string): boolean {
|
|
const stem = segment.split('.')[0]?.toUpperCase() ?? '';
|
|
return (
|
|
!segment ||
|
|
stem === 'CON' ||
|
|
stem === 'PRN' ||
|
|
stem === 'AUX' ||
|
|
stem === 'NUL' ||
|
|
/^COM[1-9]$/.test(stem) ||
|
|
/^LPT[1-9]$/.test(stem)
|
|
);
|
|
}
|
|
|
|
function encodeTaskId(taskId: string): string {
|
|
const encoded = encodeURIComponent(taskId);
|
|
return isWindowsReservedArtifactSegment(encoded) ||
|
|
encoded.length > MAX_TASK_ID_ARTIFACT_SEGMENT_LENGTH
|
|
? `task-id-${createHash('sha256').update(taskId).digest('hex').slice(0, 32)}`
|
|
: encoded;
|
|
}
|
|
|
|
function taskIdArtifactSegments(taskId: string): string[] {
|
|
const safe = encodeTaskId(taskId);
|
|
const legacy = encodeURIComponent(taskId);
|
|
return safe === legacy ? [safe] : [safe, legacy];
|
|
}
|
|
|
|
function taskArtifactPathCandidates(
|
|
projectDir: string,
|
|
taskId: string,
|
|
dirName: string,
|
|
fileSuffix: string
|
|
): string[] {
|
|
return taskIdArtifactSegments(taskId).map((segment) =>
|
|
path.join(projectDir, dirName, `${segment}${fileSuffix}`)
|
|
);
|
|
}
|
|
|
|
type LedgerConfidence = 'exact' | 'high' | 'medium' | 'low' | 'ambiguous';
|
|
|
|
interface LedgerContentRef {
|
|
sha256: string;
|
|
sizeBytes: number;
|
|
blobRef?: string;
|
|
unavailableReason?: string;
|
|
}
|
|
|
|
interface LedgerEvent {
|
|
schemaVersion: typeof TASK_CHANGE_JOURNAL_SCHEMA_VERSION;
|
|
eventId: string;
|
|
taskId: string;
|
|
taskRef: string;
|
|
taskRefKind: 'canonical' | 'display' | 'unknown';
|
|
phase: 'work' | 'review';
|
|
executionSeq: number;
|
|
sessionId: string;
|
|
agentId?: string;
|
|
memberName?: string;
|
|
toolUseId: string;
|
|
source:
|
|
| 'file_edit'
|
|
| 'file_write'
|
|
| 'notebook_edit'
|
|
| 'bash_simulated_sed'
|
|
| 'shell_snapshot'
|
|
| 'powershell_snapshot'
|
|
| 'post_tool_hook_snapshot';
|
|
operation: 'create' | 'modify' | 'delete';
|
|
confidence: LedgerConfidence;
|
|
workspaceRoot: string;
|
|
filePath: string;
|
|
relativePath: string;
|
|
timestamp: string;
|
|
toolStatus: 'succeeded' | 'failed' | 'killed' | 'backgrounded';
|
|
before: LedgerContentRef | null;
|
|
after: LedgerContentRef | null;
|
|
beforeState?: LedgerContentState;
|
|
afterState?: LedgerContentState;
|
|
relation?: LedgerChangeRelation;
|
|
oldString?: string;
|
|
newString?: string;
|
|
linesAdded?: number;
|
|
linesRemoved?: number;
|
|
replaceAll?: boolean;
|
|
warnings?: string[];
|
|
}
|
|
|
|
interface LedgerNotice {
|
|
schemaVersion: typeof TASK_CHANGE_JOURNAL_SCHEMA_VERSION;
|
|
noticeId: string;
|
|
taskId: string;
|
|
taskRef: string;
|
|
taskRefKind: 'canonical' | 'display' | 'unknown';
|
|
phase: 'work' | 'review';
|
|
executionSeq: number;
|
|
sessionId: string;
|
|
agentId?: string;
|
|
memberName?: string;
|
|
toolUseId: string;
|
|
timestamp: string;
|
|
severity: 'warning';
|
|
message: string;
|
|
code?: 'multi-scope-skipped' | 'journal-recovered' | 'writer-lock-stolen';
|
|
}
|
|
|
|
interface LedgerBundleFileV1 {
|
|
filePath: string;
|
|
relativePath: string;
|
|
eventIds: string[];
|
|
linesAdded: number;
|
|
linesRemoved: number;
|
|
isNewFile: boolean;
|
|
latestAfterHash: string | null;
|
|
}
|
|
|
|
interface LedgerBundleV1 {
|
|
schemaVersion: 1;
|
|
source: 'task-change-ledger';
|
|
taskId: string;
|
|
generatedAt: string;
|
|
eventCount: number;
|
|
files: LedgerBundleFileV1[];
|
|
totalLinesAdded: number;
|
|
totalLinesRemoved: number;
|
|
totalFiles: number;
|
|
confidence: 'high' | 'medium' | 'low';
|
|
warnings: string[];
|
|
events: LedgerEvent[];
|
|
notices?: LedgerNotice[];
|
|
}
|
|
|
|
interface LedgerSummaryContributorV2 {
|
|
actorKey: string;
|
|
agentId?: string;
|
|
memberName?: string;
|
|
eventCount: number;
|
|
noticeCount: number;
|
|
touchedFileCount: number;
|
|
visibleFileCount: number;
|
|
toolUseCount: number;
|
|
cumulativeLinesAdded: number;
|
|
cumulativeLinesRemoved: number;
|
|
firstTimestamp: string;
|
|
lastTimestamp: string;
|
|
}
|
|
|
|
interface LedgerSummaryScopeV2 {
|
|
confidence: TaskChangeScope['confidence'];
|
|
primaryActorKey?: string;
|
|
primaryAgentId?: string;
|
|
primaryMemberName?: string;
|
|
memberName: string;
|
|
agentIds: string[];
|
|
memberNames?: string[];
|
|
startTimestamp: string;
|
|
endTimestamp: string;
|
|
toolUseIds: string[];
|
|
toolUseCount: number;
|
|
toolUseIdsTruncated?: boolean;
|
|
phaseSet: Array<'work' | 'review'>;
|
|
executionSeqRange?: { start: number; end: number };
|
|
confidenceBreakdown?: TaskChangeScope['confidenceBreakdown'];
|
|
visibleFileCount: number;
|
|
contributors: LedgerSummaryContributorV2[];
|
|
}
|
|
|
|
interface LedgerSummaryFileV2 {
|
|
changeKey: string;
|
|
filePath: string;
|
|
relativePath: string;
|
|
displayPath?: string;
|
|
linesAdded: number;
|
|
linesRemoved: number;
|
|
diffStatKnown: boolean;
|
|
eventCount: number;
|
|
firstTimestamp: string;
|
|
lastTimestamp: string;
|
|
latestOperation: 'create' | 'modify' | 'delete';
|
|
createdInTask: boolean;
|
|
deletedInTask: boolean;
|
|
baselineExists?: boolean;
|
|
finalExists?: boolean;
|
|
latestBeforeHash: string | null;
|
|
latestAfterHash: string | null;
|
|
latestBeforeState?: LedgerContentState;
|
|
latestAfterState?: LedgerContentState;
|
|
contentAvailability: 'full-text' | 'hash-only' | 'metadata-only';
|
|
reviewability: 'full-text' | 'partial-text' | 'metadata-only';
|
|
relation?: LedgerChangeRelation;
|
|
primaryActorKey?: string;
|
|
agentIds: string[];
|
|
memberNames?: string[];
|
|
executionSeqRange?: { start: number; end: number };
|
|
warnings?: string[];
|
|
}
|
|
|
|
interface LedgerSummaryBundleV2 {
|
|
schemaVersion: typeof TASK_CHANGE_SUMMARY_SCHEMA_VERSION;
|
|
source: 'task-change-ledger';
|
|
bundleKind: 'summary';
|
|
taskId: string;
|
|
generatedAt: string;
|
|
journalStamp: TaskChangeJournalStamp;
|
|
integrity: 'ok' | 'recovered' | 'partial';
|
|
eventCount: number;
|
|
noticeCount: number;
|
|
scope: LedgerSummaryScopeV2;
|
|
files: LedgerSummaryFileV2[];
|
|
totalLinesAdded: number;
|
|
totalLinesRemoved: number;
|
|
diffStatCompleteness: 'complete' | 'partial';
|
|
totalFiles: number;
|
|
confidence: 'high' | 'medium' | 'low';
|
|
warningCount: number;
|
|
warnings: string[];
|
|
}
|
|
|
|
interface LedgerFreshnessV2 {
|
|
schemaVersion: typeof TASK_CHANGE_FRESHNESS_SCHEMA_VERSION;
|
|
source: 'task-change-ledger';
|
|
taskId: string;
|
|
updatedAt: string;
|
|
journalStamp: TaskChangeJournalStamp;
|
|
eventCount: number;
|
|
noticeCount: number;
|
|
integrity: 'ok' | 'recovered' | 'partial';
|
|
bundleSchemaVersion: 2;
|
|
bundleKind: 'summary';
|
|
}
|
|
|
|
type JournalReadResult<T> = {
|
|
entries: T[];
|
|
recovered: boolean;
|
|
};
|
|
|
|
type JournalData = {
|
|
events: LedgerEvent[];
|
|
notices: LedgerNotice[];
|
|
recovered: boolean;
|
|
};
|
|
|
|
type SummaryBundleRead = {
|
|
bundle: LedgerSummaryBundleV2;
|
|
provenance: TaskChangeProvenance;
|
|
mode: 'validated' | 'degraded';
|
|
degradedWarning?: string;
|
|
};
|
|
|
|
export class TaskChangeLedgerReader {
|
|
async readTaskChanges(params: {
|
|
teamName: string;
|
|
taskId: string;
|
|
projectDir: string;
|
|
projectPath?: string;
|
|
includeDetails: boolean;
|
|
}): Promise<TaskChangeSetV2 | null> {
|
|
const bundleRead = await this.tryReadSummaryBundleV2(
|
|
params.projectDir,
|
|
params.taskId,
|
|
params.projectPath
|
|
);
|
|
|
|
if (params.includeDetails) {
|
|
const journal = await this.readJournalData(params.projectDir, params.taskId);
|
|
if (journal) {
|
|
return this.buildDetailedResult({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectDir: params.projectDir,
|
|
projectPath: params.projectPath,
|
|
journal,
|
|
bundle: bundleRead?.bundle,
|
|
provenance:
|
|
bundleRead?.provenance ??
|
|
this.buildLedgerProvenanceFromJournal(
|
|
(await this.readJournalStampFromDisk(params.projectDir, params.taskId)) ?? {},
|
|
undefined,
|
|
journal.recovered ? 'recovered' : 'ok'
|
|
),
|
|
});
|
|
}
|
|
|
|
const legacy = await this.readLegacyBundleV1(params.projectDir, params.taskId);
|
|
if (legacy) {
|
|
return this.buildLegacyResult({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectDir: params.projectDir,
|
|
projectPath: params.projectPath,
|
|
bundle: legacy,
|
|
includeDetails: true,
|
|
});
|
|
}
|
|
|
|
if (bundleRead) {
|
|
const result = this.buildSummaryResultFromBundle({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectPath: params.projectPath,
|
|
bundle: bundleRead.bundle,
|
|
provenance: bundleRead.provenance,
|
|
extraWarnings: bundleRead.degradedWarning ? [bundleRead.degradedWarning] : undefined,
|
|
});
|
|
return {
|
|
...result,
|
|
warnings: [
|
|
...result.warnings,
|
|
'Ledger journal was unavailable; detailed snippets could not be loaded.',
|
|
],
|
|
};
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
if (bundleRead?.mode === 'validated') {
|
|
return this.buildSummaryResultFromBundle({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectPath: params.projectPath,
|
|
bundle: bundleRead.bundle,
|
|
provenance: bundleRead.provenance,
|
|
});
|
|
}
|
|
|
|
const journal = await this.readJournalData(params.projectDir, params.taskId);
|
|
if (journal) {
|
|
return this.buildJournalFallbackSummary({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectDir: params.projectDir,
|
|
projectPath: params.projectPath,
|
|
journal,
|
|
});
|
|
}
|
|
|
|
if (bundleRead) {
|
|
return this.buildSummaryResultFromBundle({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectPath: params.projectPath,
|
|
bundle: bundleRead.bundle,
|
|
provenance: bundleRead.provenance,
|
|
extraWarnings: bundleRead.degradedWarning ? [bundleRead.degradedWarning] : undefined,
|
|
});
|
|
}
|
|
|
|
const legacy = await this.readLegacyBundleV1(params.projectDir, params.taskId);
|
|
if (legacy) {
|
|
return this.buildLegacyResult({
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
projectDir: params.projectDir,
|
|
projectPath: params.projectPath,
|
|
bundle: legacy,
|
|
includeDetails: false,
|
|
});
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private async tryReadSummaryBundleV2(
|
|
projectDir: string,
|
|
taskId: string,
|
|
_projectPath?: string
|
|
): Promise<SummaryBundleRead | null> {
|
|
const [bundle, freshness, journalStamp] = await Promise.all([
|
|
this.readSummaryBundleV2(projectDir, taskId),
|
|
this.readFreshnessV2(projectDir, taskId),
|
|
this.readJournalStampFromDisk(projectDir, taskId),
|
|
]);
|
|
if (!bundle) {
|
|
return null;
|
|
}
|
|
|
|
const provenance = this.buildLedgerProvenance(
|
|
bundle.journalStamp,
|
|
bundle.integrity,
|
|
bundle.schemaVersion
|
|
);
|
|
|
|
if (
|
|
freshness &&
|
|
this.bundleMatchesFreshness(bundle, freshness) &&
|
|
freshness.integrity !== 'partial'
|
|
) {
|
|
return { bundle, provenance, mode: 'validated' };
|
|
}
|
|
|
|
if (
|
|
!freshness &&
|
|
journalStamp &&
|
|
JSON.stringify(journalStamp) === JSON.stringify(bundle.journalStamp) &&
|
|
bundle.integrity !== 'partial'
|
|
) {
|
|
return {
|
|
bundle,
|
|
provenance: this.buildLedgerProvenance(
|
|
journalStamp,
|
|
bundle.integrity,
|
|
bundle.schemaVersion
|
|
),
|
|
mode: 'validated',
|
|
};
|
|
}
|
|
|
|
if (!freshness && !journalStamp) {
|
|
return {
|
|
bundle,
|
|
provenance,
|
|
mode: 'degraded',
|
|
degradedWarning:
|
|
'Task change summary used bundle v2 without live validation because freshness and journal files were unavailable.',
|
|
};
|
|
}
|
|
|
|
return {
|
|
bundle,
|
|
provenance,
|
|
mode: 'degraded',
|
|
degradedWarning:
|
|
'Task change summary bypassed bundle v2 fast-path because bundle freshness did not match the current ledger generation.',
|
|
};
|
|
}
|
|
|
|
private async readSummaryBundleV2(
|
|
projectDir: string,
|
|
taskId: string
|
|
): Promise<LedgerSummaryBundleV2 | null> {
|
|
const bundlePaths = taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
path.join(TASK_CHANGE_LEDGER_DIRNAME, 'bundles'),
|
|
'.json'
|
|
);
|
|
for (const bundlePath of bundlePaths) {
|
|
try {
|
|
const raw = await readFile(bundlePath, 'utf8');
|
|
const parsed = JSON.parse(raw) as Partial<LedgerSummaryBundleV2>;
|
|
if (
|
|
parsed?.schemaVersion !== TASK_CHANGE_SUMMARY_SCHEMA_VERSION ||
|
|
parsed.source !== 'task-change-ledger' ||
|
|
parsed.bundleKind !== 'summary' ||
|
|
parsed.taskId !== taskId ||
|
|
!Array.isArray(parsed.files)
|
|
) {
|
|
return null;
|
|
}
|
|
return parsed as LedgerSummaryBundleV2;
|
|
} catch {
|
|
continue;
|
|
}
|
|
}
|
|
logger.debug(`No v2 task-change bundle for ${taskId}.`);
|
|
return null;
|
|
}
|
|
|
|
private async readFreshnessV2(
|
|
projectDir: string,
|
|
taskId: string
|
|
): Promise<LedgerFreshnessV2 | null> {
|
|
const freshnessPaths = taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
TASK_CHANGE_FRESHNESS_DIRNAME,
|
|
'.json'
|
|
);
|
|
for (const freshnessPath of freshnessPaths) {
|
|
try {
|
|
const raw = await readFile(freshnessPath, 'utf8');
|
|
const parsed = JSON.parse(raw) as Partial<LedgerFreshnessV2>;
|
|
if (
|
|
parsed?.schemaVersion !== TASK_CHANGE_FRESHNESS_SCHEMA_VERSION ||
|
|
parsed.source !== 'task-change-ledger' ||
|
|
parsed.taskId !== taskId ||
|
|
parsed.bundleKind !== 'summary'
|
|
) {
|
|
return null;
|
|
}
|
|
return parsed as LedgerFreshnessV2;
|
|
} catch {
|
|
continue;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private async readLegacyBundleV1(
|
|
projectDir: string,
|
|
taskId: string
|
|
): Promise<LedgerBundleV1 | null> {
|
|
const bundlePaths = taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
path.join(TASK_CHANGE_LEDGER_DIRNAME, 'bundles'),
|
|
'.json'
|
|
);
|
|
for (const bundlePath of bundlePaths) {
|
|
try {
|
|
const raw = await readFile(bundlePath, 'utf8');
|
|
const parsed = JSON.parse(raw) as Partial<LedgerBundleV1>;
|
|
if (
|
|
parsed?.schemaVersion !== 1 ||
|
|
parsed.source !== 'task-change-ledger' ||
|
|
parsed.taskId !== taskId ||
|
|
!Array.isArray(parsed.events)
|
|
) {
|
|
return null;
|
|
}
|
|
return parsed as LedgerBundleV1;
|
|
} catch {
|
|
continue;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private async readJournalData(projectDir: string, taskId: string): Promise<JournalData | null> {
|
|
const [events, notices] = await Promise.all([
|
|
this.readJournalEntries<LedgerEvent>({
|
|
filePath: taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
path.join(TASK_CHANGE_LEDGER_DIRNAME, 'events'),
|
|
'.jsonl'
|
|
),
|
|
taskId,
|
|
schemaVersion: TASK_CHANGE_JOURNAL_SCHEMA_VERSION,
|
|
idField: 'eventId',
|
|
}),
|
|
this.readJournalEntries<LedgerNotice>({
|
|
filePath: taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
path.join(TASK_CHANGE_LEDGER_DIRNAME, 'notices'),
|
|
'.jsonl'
|
|
),
|
|
taskId,
|
|
schemaVersion: TASK_CHANGE_JOURNAL_SCHEMA_VERSION,
|
|
idField: 'noticeId',
|
|
}),
|
|
]);
|
|
|
|
if (events.entries.length === 0 && notices.entries.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
events: events.entries,
|
|
notices: notices.entries,
|
|
recovered: events.recovered || notices.recovered,
|
|
};
|
|
}
|
|
|
|
private async readJournalEntries<T extends { taskId: string; schemaVersion: number }>(params: {
|
|
filePath: string | string[];
|
|
taskId: string;
|
|
schemaVersion: number;
|
|
idField: 'eventId' | 'noticeId';
|
|
}): Promise<JournalReadResult<T>> {
|
|
let raw: string | null = null;
|
|
for (const filePath of Array.isArray(params.filePath) ? params.filePath : [params.filePath]) {
|
|
try {
|
|
raw = await readFile(filePath, 'utf8');
|
|
break;
|
|
} catch {
|
|
continue;
|
|
}
|
|
}
|
|
if (raw === null) {
|
|
return { entries: [], recovered: false };
|
|
}
|
|
|
|
const entries: T[] = [];
|
|
const seenIds = new Set<string>();
|
|
let recovered = false;
|
|
for (const line of raw.split('\n')) {
|
|
if (!line.trim()) continue;
|
|
try {
|
|
const parsed = JSON.parse(line) as T & Record<string, unknown>;
|
|
const id = parsed?.[params.idField];
|
|
if (
|
|
parsed?.schemaVersion !== params.schemaVersion ||
|
|
parsed.taskId !== params.taskId ||
|
|
typeof id !== 'string'
|
|
) {
|
|
recovered = true;
|
|
continue;
|
|
}
|
|
if (seenIds.has(id)) {
|
|
recovered = true;
|
|
continue;
|
|
}
|
|
seenIds.add(id);
|
|
entries.push(parsed);
|
|
} catch {
|
|
recovered = true;
|
|
}
|
|
}
|
|
return { entries, recovered };
|
|
}
|
|
|
|
private bundleMatchesFreshness(
|
|
bundle: LedgerSummaryBundleV2,
|
|
freshness: LedgerFreshnessV2
|
|
): boolean {
|
|
return (
|
|
JSON.stringify(bundle.journalStamp) === JSON.stringify(freshness.journalStamp) &&
|
|
bundle.eventCount === freshness.eventCount &&
|
|
bundle.noticeCount === freshness.noticeCount &&
|
|
freshness.bundleSchemaVersion === bundle.schemaVersion &&
|
|
freshness.bundleKind === bundle.bundleKind
|
|
);
|
|
}
|
|
|
|
private buildLedgerProvenance(
|
|
journalStamp: TaskChangeJournalStamp,
|
|
integrity: 'ok' | 'recovered' | 'partial',
|
|
bundleSchemaVersion?: number
|
|
): TaskChangeProvenance {
|
|
return {
|
|
sourceKind: 'ledger',
|
|
sourceFingerprint: this.hashFingerprintPayload({
|
|
journalStamp,
|
|
integrity,
|
|
...(bundleSchemaVersion ? { bundleSchemaVersion } : {}),
|
|
}),
|
|
journalStamp,
|
|
...(bundleSchemaVersion ? { bundleSchemaVersion } : {}),
|
|
integrity,
|
|
};
|
|
}
|
|
|
|
private buildLedgerProvenanceFromJournal(
|
|
journalStamp: TaskChangeJournalStamp,
|
|
bundleSchemaVersion?: number,
|
|
integrity: 'ok' | 'recovered' | 'partial' = 'ok'
|
|
): TaskChangeProvenance {
|
|
return this.buildLedgerProvenance(journalStamp, integrity, bundleSchemaVersion);
|
|
}
|
|
|
|
private hashFingerprintPayload(payload: unknown): string {
|
|
return createHash('sha256').update(JSON.stringify(payload)).digest('hex');
|
|
}
|
|
|
|
private async readJournalStampFromDisk(
|
|
projectDir: string,
|
|
taskId: string
|
|
): Promise<TaskChangeJournalStamp | null> {
|
|
const readFileStamp = async (filePaths: string[]) => {
|
|
let handle: Awaited<ReturnType<typeof open>> | null = null;
|
|
for (const filePath of filePaths) {
|
|
try {
|
|
handle = await open(filePath, 'r');
|
|
const fileStat = await handle.stat();
|
|
if (!fileStat.isFile()) {
|
|
continue;
|
|
}
|
|
const tailLength = Math.min(fileStat.size, 4096);
|
|
const tail = Buffer.alloc(tailLength);
|
|
if (tailLength > 0) {
|
|
await handle.read(tail, 0, tailLength, fileStat.size - tailLength);
|
|
}
|
|
return {
|
|
bytes: fileStat.size,
|
|
mtimeMs: fileStat.mtimeMs,
|
|
tailSha256: tailLength > 0 ? createHash('sha256').update(tail).digest('hex') : null,
|
|
};
|
|
} catch {
|
|
continue;
|
|
} finally {
|
|
await handle?.close().catch(() => undefined);
|
|
handle = null;
|
|
}
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
const [events, notices] = await Promise.all([
|
|
readFileStamp(
|
|
taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
path.join(TASK_CHANGE_LEDGER_DIRNAME, 'events'),
|
|
'.jsonl'
|
|
)
|
|
),
|
|
readFileStamp(
|
|
taskArtifactPathCandidates(
|
|
projectDir,
|
|
taskId,
|
|
path.join(TASK_CHANGE_LEDGER_DIRNAME, 'notices'),
|
|
'.jsonl'
|
|
)
|
|
),
|
|
]);
|
|
|
|
if (!events && !notices) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
...(events ? { events } : {}),
|
|
...(notices ? { notices } : {}),
|
|
};
|
|
}
|
|
|
|
private buildSummaryResultFromBundle(params: {
|
|
teamName: string;
|
|
taskId: string;
|
|
projectPath?: string;
|
|
bundle: LedgerSummaryBundleV2;
|
|
provenance: TaskChangeProvenance;
|
|
extraWarnings?: string[];
|
|
}): TaskChangeSetV2 {
|
|
return {
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
files: params.bundle.files.map((file) => this.mapV2SummaryFile(file, params.projectPath)),
|
|
totalLinesAdded: params.bundle.totalLinesAdded,
|
|
totalLinesRemoved: params.bundle.totalLinesRemoved,
|
|
totalFiles: params.bundle.totalFiles,
|
|
confidence: params.bundle.confidence,
|
|
computedAt: params.bundle.generatedAt,
|
|
scope: this.mapV2Scope(params.taskId, params.bundle.scope, params.bundle.files),
|
|
warnings: [...params.bundle.warnings, ...(params.extraWarnings ?? [])],
|
|
diffStatCompleteness: params.bundle.diffStatCompleteness,
|
|
provenance: params.provenance,
|
|
};
|
|
}
|
|
|
|
private async buildDetailedResult(params: {
|
|
teamName: string;
|
|
taskId: string;
|
|
projectDir: string;
|
|
projectPath?: string;
|
|
journal: JournalData;
|
|
bundle?: LedgerSummaryBundleV2;
|
|
provenance: TaskChangeProvenance;
|
|
}): Promise<TaskChangeSetV2> {
|
|
const snippets = await this.buildSnippets(params.projectDir, params.journal.events);
|
|
const groupedSnippets = this.groupSnippets(snippets);
|
|
const warnings = this.collectWarnings(params.journal.events, params.journal.notices, {
|
|
recovered: params.journal.recovered,
|
|
});
|
|
|
|
let files: FileChangeSummary[];
|
|
let totalLinesAdded: number;
|
|
let totalLinesRemoved: number;
|
|
let totalFiles: number;
|
|
let confidence: TaskChangeSetV2['confidence'];
|
|
let scope: TaskChangeScope;
|
|
let diffStatCompleteness: 'complete' | 'partial' | undefined;
|
|
|
|
if (params.bundle) {
|
|
files = params.bundle.files.map((file) => {
|
|
const groupKey = this.groupKeyForFileSummary(file.filePath, file.relation);
|
|
const entry = groupedSnippets.get(groupKey);
|
|
return {
|
|
...this.mapV2SummaryFile(file, params.projectPath),
|
|
snippets: entry?.snippets ?? [],
|
|
timeline: entry ? this.buildTimeline(file.filePath, entry.snippets) : undefined,
|
|
};
|
|
});
|
|
totalLinesAdded = params.bundle.totalLinesAdded;
|
|
totalLinesRemoved = params.bundle.totalLinesRemoved;
|
|
totalFiles = params.bundle.totalFiles;
|
|
confidence = params.bundle.confidence;
|
|
scope = this.mapV2Scope(params.taskId, params.bundle.scope, params.bundle.files);
|
|
diffStatCompleteness = params.bundle.diffStatCompleteness;
|
|
} else {
|
|
const fallback = this.buildFallbackFilesFromGroupedSnippets(
|
|
groupedSnippets,
|
|
params.projectPath
|
|
);
|
|
files = fallback.files;
|
|
totalLinesAdded = fallback.totalLinesAdded;
|
|
totalLinesRemoved = fallback.totalLinesRemoved;
|
|
totalFiles = fallback.files.length;
|
|
confidence = params.journal.events.some((event) => event.confidence === 'low')
|
|
? 'low'
|
|
: params.journal.events.some((event) => event.confidence === 'medium')
|
|
? 'medium'
|
|
: 'high';
|
|
scope = this.buildFallbackScope(
|
|
params.taskId,
|
|
files,
|
|
params.journal.events,
|
|
params.journal.notices
|
|
);
|
|
diffStatCompleteness = fallback.files.every((file) => file.diffStatKnown !== false)
|
|
? 'complete'
|
|
: 'partial';
|
|
warnings.push(
|
|
'Ledger detail view fell back to journal reconstruction because summary bundle v2 was unavailable.'
|
|
);
|
|
}
|
|
|
|
return {
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
files,
|
|
totalLinesAdded,
|
|
totalLinesRemoved,
|
|
totalFiles,
|
|
confidence,
|
|
computedAt: params.bundle?.generatedAt ?? new Date().toISOString(),
|
|
scope,
|
|
warnings,
|
|
...(diffStatCompleteness ? { diffStatCompleteness } : {}),
|
|
provenance: params.provenance,
|
|
};
|
|
}
|
|
|
|
private async buildJournalFallbackSummary(params: {
|
|
teamName: string;
|
|
taskId: string;
|
|
projectDir: string;
|
|
projectPath?: string;
|
|
journal: JournalData;
|
|
}): Promise<TaskChangeSetV2> {
|
|
const provenance = this.buildLedgerProvenanceFromJournal(
|
|
(await this.readJournalStampFromDisk(params.projectDir, params.taskId)) ?? {},
|
|
undefined,
|
|
params.journal.recovered ? 'recovered' : 'ok'
|
|
);
|
|
const snippets = params.journal.events.map((event) => this.eventToSnippet(event, null, null));
|
|
const grouped = this.groupSnippets(snippets);
|
|
const fallback = this.buildFallbackFilesFromGroupedSnippets(grouped, params.projectPath);
|
|
return {
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
files: fallback.files.map((file) => ({ ...file, snippets: [] })),
|
|
totalLinesAdded: fallback.totalLinesAdded,
|
|
totalLinesRemoved: fallback.totalLinesRemoved,
|
|
totalFiles: fallback.files.length,
|
|
confidence: params.journal.events.some((event) => event.confidence === 'low')
|
|
? 'low'
|
|
: params.journal.events.some((event) => event.confidence === 'medium')
|
|
? 'medium'
|
|
: 'high',
|
|
computedAt: new Date().toISOString(),
|
|
scope: this.buildFallbackScope(
|
|
params.taskId,
|
|
fallback.files,
|
|
params.journal.events,
|
|
params.journal.notices
|
|
),
|
|
warnings: [
|
|
...this.collectWarnings(params.journal.events, params.journal.notices, {
|
|
recovered: params.journal.recovered,
|
|
}),
|
|
'Task change summary fell back to journal reconstruction.',
|
|
],
|
|
diffStatCompleteness: fallback.files.every((file) => file.diffStatKnown !== false)
|
|
? 'complete'
|
|
: 'partial',
|
|
provenance,
|
|
};
|
|
}
|
|
|
|
private async buildLegacyResult(params: {
|
|
teamName: string;
|
|
taskId: string;
|
|
projectDir: string;
|
|
projectPath?: string;
|
|
bundle: LedgerBundleV1;
|
|
includeDetails: boolean;
|
|
}): Promise<TaskChangeSetV2> {
|
|
const snippets = params.includeDetails
|
|
? await this.buildSnippets(params.projectDir, params.bundle.events)
|
|
: params.bundle.events.map((event) => this.eventToSnippet(event, null, null));
|
|
const grouped = this.groupSnippets(snippets);
|
|
const fallback = this.buildFallbackFilesFromGroupedSnippets(grouped, params.projectPath);
|
|
const warnings = new Set<string>(params.bundle.warnings ?? []);
|
|
warnings.add(
|
|
'Task change ledger used legacy bundle v1 compatibility mode; summary was derived from legacy events.'
|
|
);
|
|
for (const notice of params.bundle.notices ?? []) warnings.add(notice.message);
|
|
|
|
return {
|
|
teamName: params.teamName,
|
|
taskId: params.taskId,
|
|
files: params.includeDetails
|
|
? fallback.files
|
|
: fallback.files.map((file) => ({ ...file, snippets: [], timeline: undefined })),
|
|
totalLinesAdded: fallback.totalLinesAdded,
|
|
totalLinesRemoved: fallback.totalLinesRemoved,
|
|
totalFiles: fallback.files.length,
|
|
confidence: params.bundle.confidence,
|
|
computedAt: params.bundle.generatedAt,
|
|
scope: this.buildFallbackScope(
|
|
params.taskId,
|
|
fallback.files,
|
|
params.bundle.events,
|
|
params.bundle.notices ?? []
|
|
),
|
|
warnings: [...warnings],
|
|
diffStatCompleteness: fallback.files.every((file) => file.diffStatKnown !== false)
|
|
? 'complete'
|
|
: 'partial',
|
|
provenance: {
|
|
sourceKind: 'ledger',
|
|
sourceFingerprint: this.hashFingerprintPayload({
|
|
legacyTaskId: params.taskId,
|
|
generatedAt: params.bundle.generatedAt,
|
|
eventCount: params.bundle.eventCount,
|
|
}),
|
|
},
|
|
};
|
|
}
|
|
|
|
private mapV2SummaryFile(file: LedgerSummaryFileV2, projectPath?: string): FileChangeSummary {
|
|
const displayPath = file.displayPath ?? file.filePath;
|
|
const filePath = this.normalizeLedgerFilePath(file.filePath);
|
|
return {
|
|
filePath,
|
|
relativePath: this.relativePath(displayPath, projectPath, file.relativePath),
|
|
snippets: [],
|
|
linesAdded: file.linesAdded,
|
|
linesRemoved: file.linesRemoved,
|
|
isNewFile: Boolean(
|
|
file.createdInTask && file.latestOperation !== 'delete' && file.relation?.kind !== 'rename'
|
|
),
|
|
changeKey: this.normalizeSummaryChangeKey(file),
|
|
diffStatKnown: file.diffStatKnown,
|
|
ledgerSummary: {
|
|
latestOperation: file.latestOperation,
|
|
createdInTask: file.createdInTask,
|
|
deletedInTask: file.deletedInTask,
|
|
contentAvailability: file.contentAvailability,
|
|
reviewability: file.reviewability,
|
|
...(file.relation ? { relation: file.relation } : {}),
|
|
...(file.latestBeforeState ? { beforeState: file.latestBeforeState } : {}),
|
|
...(file.latestAfterState ? { afterState: file.latestAfterState } : {}),
|
|
...(file.primaryActorKey ? { primaryActorKey: file.primaryActorKey } : {}),
|
|
...(file.agentIds.length > 0 ? { agentIds: file.agentIds } : {}),
|
|
...(file.memberNames ? { memberNames: file.memberNames } : {}),
|
|
...(file.executionSeqRange ? { executionSeqRange: file.executionSeqRange } : {}),
|
|
},
|
|
};
|
|
}
|
|
|
|
private normalizeSummaryChangeKey(file: LedgerSummaryFileV2): string {
|
|
if (file.relation) {
|
|
return `${file.relation.kind}:${normalizePathForComparison(file.relation.oldPath)}->${normalizePathForComparison(file.relation.newPath)}`;
|
|
}
|
|
const slashNormalized = file.changeKey.replace(/\\/g, '/');
|
|
const pathKeyMatch = /^(path|create|delete):(.+)$/.exec(slashNormalized);
|
|
if (pathKeyMatch) {
|
|
return `${pathKeyMatch[1]}:${normalizePathForComparison(pathKeyMatch[2] ?? '')}`;
|
|
}
|
|
return slashNormalized;
|
|
}
|
|
|
|
private mapV2Scope(
|
|
taskId: string,
|
|
scope: LedgerSummaryScopeV2,
|
|
files: LedgerSummaryFileV2[]
|
|
): TaskChangeScope {
|
|
return {
|
|
taskId,
|
|
memberName:
|
|
scope.memberName ||
|
|
scope.primaryMemberName ||
|
|
scope.primaryAgentId ||
|
|
scope.primaryActorKey ||
|
|
'',
|
|
startLine: 0,
|
|
endLine: 0,
|
|
startTimestamp: scope.startTimestamp,
|
|
endTimestamp: scope.endTimestamp,
|
|
toolUseIds: scope.toolUseIds,
|
|
filePaths: files.map((file) => this.normalizeLedgerFilePath(file.filePath)),
|
|
confidence: scope.confidence,
|
|
...(scope.primaryActorKey ? { primaryActorKey: scope.primaryActorKey } : {}),
|
|
...(scope.primaryAgentId ? { primaryAgentId: scope.primaryAgentId } : {}),
|
|
...(scope.primaryMemberName ? { primaryMemberName: scope.primaryMemberName } : {}),
|
|
...(scope.agentIds.length > 0 ? { agentIds: scope.agentIds } : {}),
|
|
...(scope.memberNames ? { memberNames: scope.memberNames } : {}),
|
|
...(scope.toolUseCount !== undefined ? { toolUseCount: scope.toolUseCount } : {}),
|
|
...(scope.toolUseIdsTruncated ? { toolUseIdsTruncated: true } : {}),
|
|
...(scope.phaseSet ? { phaseSet: scope.phaseSet } : {}),
|
|
...(scope.executionSeqRange ? { executionSeqRange: scope.executionSeqRange } : {}),
|
|
...(scope.confidenceBreakdown ? { confidenceBreakdown: scope.confidenceBreakdown } : {}),
|
|
...(scope.contributors ? { contributors: scope.contributors } : {}),
|
|
};
|
|
}
|
|
|
|
private async buildSnippets(projectDir: string, events: LedgerEvent[]): Promise<SnippetDiff[]> {
|
|
return Promise.all(
|
|
events.map(async (event) => {
|
|
const beforeContent = await this.readContentRef(projectDir, event.before);
|
|
const afterContent = await this.readContentRef(projectDir, event.after);
|
|
return this.eventToSnippet(event, beforeContent, afterContent);
|
|
})
|
|
);
|
|
}
|
|
|
|
private async readContentRef(
|
|
projectDir: string,
|
|
ref: LedgerContentRef | null
|
|
): Promise<string | null> {
|
|
if (!ref?.blobRef) {
|
|
return null;
|
|
}
|
|
try {
|
|
return await readFile(
|
|
path.join(projectDir, TASK_CHANGE_LEDGER_DIRNAME, 'blobs', ref.blobRef),
|
|
'utf8'
|
|
);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private eventToSnippet(
|
|
event: LedgerEvent,
|
|
beforeContent: string | null,
|
|
afterContent: string | null
|
|
): SnippetDiff {
|
|
const filePath = this.normalizeLedgerFilePath(event.filePath);
|
|
return {
|
|
toolUseId: event.toolUseId,
|
|
filePath,
|
|
toolName: this.mapToolName(event.source),
|
|
type: this.mapSnippetType(event),
|
|
oldString: event.oldString ?? beforeContent ?? '',
|
|
newString: event.newString ?? afterContent ?? '',
|
|
replaceAll: event.replaceAll ?? false,
|
|
timestamp: event.timestamp,
|
|
isError: false,
|
|
ledger: {
|
|
eventId: event.eventId,
|
|
source: event.confidence === 'exact' ? 'ledger-exact' : 'ledger-snapshot',
|
|
confidence: event.confidence,
|
|
originalFullContent: beforeContent,
|
|
modifiedFullContent: afterContent,
|
|
beforeHash: event.before?.sha256 ?? null,
|
|
afterHash: event.after?.sha256 ?? null,
|
|
operation: event.operation,
|
|
beforeState: event.beforeState,
|
|
afterState: event.afterState,
|
|
relation: event.relation,
|
|
executionSeq: event.executionSeq,
|
|
linesAdded: event.linesAdded,
|
|
linesRemoved: event.linesRemoved,
|
|
textAvailability:
|
|
beforeContent !== null && afterContent !== null
|
|
? 'full-text'
|
|
: event.oldString !== undefined || event.newString !== undefined
|
|
? 'patch-text'
|
|
: 'unavailable',
|
|
},
|
|
};
|
|
}
|
|
|
|
private mapToolName(eventSource: LedgerEvent['source']): SnippetDiff['toolName'] {
|
|
switch (eventSource) {
|
|
case 'file_edit':
|
|
return 'Edit';
|
|
case 'file_write':
|
|
return 'Write';
|
|
case 'notebook_edit':
|
|
return 'NotebookEdit';
|
|
case 'bash_simulated_sed':
|
|
case 'shell_snapshot':
|
|
return 'Bash';
|
|
case 'powershell_snapshot':
|
|
return 'PowerShell';
|
|
case 'post_tool_hook_snapshot':
|
|
return 'PostToolUse';
|
|
}
|
|
}
|
|
|
|
private mapSnippetType(event: LedgerEvent): SnippetDiff['type'] {
|
|
if (event.source === 'file_write') {
|
|
return event.operation === 'create' ? 'write-new' : 'write-update';
|
|
}
|
|
if (event.source === 'notebook_edit') {
|
|
return 'notebook-edit';
|
|
}
|
|
if (event.source === 'shell_snapshot' || event.source === 'powershell_snapshot') {
|
|
return 'shell-snapshot';
|
|
}
|
|
if (event.source === 'post_tool_hook_snapshot') {
|
|
return 'hook-snapshot';
|
|
}
|
|
return 'edit';
|
|
}
|
|
|
|
private groupSnippets(
|
|
snippets: SnippetDiff[]
|
|
): Map<string, { filePath: string; relation?: LedgerChangeRelation; snippets: SnippetDiff[] }> {
|
|
const grouped = new Map<
|
|
string,
|
|
{ filePath: string; relation?: LedgerChangeRelation; snippets: SnippetDiff[] }
|
|
>();
|
|
for (const snippet of snippets) {
|
|
const groupKey = this.groupKeyForSnippet(snippet);
|
|
const existing = grouped.get(groupKey);
|
|
if (existing) {
|
|
existing.snippets.push(snippet);
|
|
} else {
|
|
grouped.set(groupKey, {
|
|
filePath: snippet.filePath,
|
|
...(snippet.ledger?.relation ? { relation: snippet.ledger.relation } : {}),
|
|
snippets: [snippet],
|
|
});
|
|
}
|
|
}
|
|
return grouped;
|
|
}
|
|
|
|
private buildFallbackFilesFromGroupedSnippets(
|
|
grouped: Map<
|
|
string,
|
|
{ filePath: string; relation?: LedgerChangeRelation; snippets: SnippetDiff[] }
|
|
>,
|
|
projectPath?: string
|
|
): { files: FileChangeSummary[]; totalLinesAdded: number; totalLinesRemoved: number } {
|
|
const files: FileChangeSummary[] = [];
|
|
for (const entry of grouped.values()) {
|
|
const relation = entry.relation ?? this.relationForSnippets(entry.snippets);
|
|
let linesAdded = 0;
|
|
let linesRemoved = 0;
|
|
for (const snippet of entry.snippets) {
|
|
if (
|
|
typeof snippet.ledger?.linesAdded === 'number' ||
|
|
typeof snippet.ledger?.linesRemoved === 'number'
|
|
) {
|
|
linesAdded += snippet.ledger?.linesAdded ?? 0;
|
|
linesRemoved += snippet.ledger?.linesRemoved ?? 0;
|
|
continue;
|
|
}
|
|
const { added, removed } = this.countLineChanges(snippet.oldString, snippet.newString);
|
|
linesAdded += added;
|
|
linesRemoved += removed;
|
|
}
|
|
const displayPath = this.resolveGroupedDisplayPath(entry.filePath, relation, entry.snippets);
|
|
files.push({
|
|
filePath: displayPath,
|
|
relativePath: this.relativePath(displayPath, projectPath),
|
|
snippets: entry.snippets,
|
|
linesAdded,
|
|
linesRemoved,
|
|
isNewFile:
|
|
relation?.kind !== 'rename' &&
|
|
entry.snippets.some(
|
|
(snippet) => snippet.type === 'write-new' || snippet.ledger?.operation === 'create'
|
|
),
|
|
changeKey: relation
|
|
? `${relation.kind}:${normalizePathForComparison(relation.oldPath)}->${normalizePathForComparison(relation.newPath)}`
|
|
: `path:${normalizePathForComparison(displayPath)}`,
|
|
diffStatKnown: true,
|
|
ledgerSummary: {
|
|
...(relation ? { relation } : {}),
|
|
latestOperation:
|
|
entry.snippets[entry.snippets.length - 1]?.ledger?.operation ??
|
|
(entry.snippets[entry.snippets.length - 1]?.type === 'write-new' ? 'create' : 'modify'),
|
|
},
|
|
timeline: this.buildTimeline(displayPath, entry.snippets),
|
|
});
|
|
}
|
|
const totalLinesAdded = files.reduce((sum, file) => sum + file.linesAdded, 0);
|
|
const totalLinesRemoved = files.reduce((sum, file) => sum + file.linesRemoved, 0);
|
|
return { files, totalLinesAdded, totalLinesRemoved };
|
|
}
|
|
|
|
private buildFallbackScope(
|
|
taskId: string,
|
|
files: FileChangeSummary[],
|
|
events: LedgerEvent[],
|
|
notices: LedgerNotice[]
|
|
): TaskChangeScope {
|
|
const primaryMemberName = events.find((event) => event.memberName)?.memberName;
|
|
const primaryAgentId = events.find((event) => event.agentId)?.agentId;
|
|
return {
|
|
taskId,
|
|
memberName: primaryMemberName ?? primaryAgentId ?? '',
|
|
startLine: 0,
|
|
endLine: 0,
|
|
startTimestamp: events[0]?.timestamp ?? notices[0]?.timestamp ?? '',
|
|
endTimestamp:
|
|
events[events.length - 1]?.timestamp ?? notices[notices.length - 1]?.timestamp ?? '',
|
|
toolUseIds: [
|
|
...new Set([...events.map((event) => event.toolUseId), ...notices.map((n) => n.toolUseId)]),
|
|
],
|
|
filePaths: files.map((file) => file.filePath),
|
|
confidence: {
|
|
tier: events.some((event) => event.confidence !== 'exact') ? 2 : 1,
|
|
label: events.some((event) => event.confidence !== 'exact') ? 'medium' : 'high',
|
|
reason: 'Scoped by orchestrator task-change ledger',
|
|
},
|
|
...(primaryMemberName ? { primaryMemberName } : {}),
|
|
...(primaryAgentId ? { primaryAgentId } : {}),
|
|
...(events.some((event) => !!event.memberName)
|
|
? {
|
|
memberNames: [
|
|
...new Set(events.flatMap((event) => (event.memberName ? [event.memberName] : []))),
|
|
].sort(),
|
|
}
|
|
: {}),
|
|
...(events.length > 0
|
|
? {
|
|
executionSeqRange: {
|
|
start: Math.min(...events.map((event) => event.executionSeq)),
|
|
end: Math.max(...events.map((event) => event.executionSeq)),
|
|
},
|
|
}
|
|
: {}),
|
|
};
|
|
}
|
|
|
|
private collectWarnings(
|
|
events: LedgerEvent[],
|
|
notices: LedgerNotice[],
|
|
options: { recovered: boolean }
|
|
): string[] {
|
|
const warnings = new Set<string>();
|
|
for (const notice of notices) warnings.add(notice.message);
|
|
for (const event of events) {
|
|
for (const warning of event.warnings ?? []) warnings.add(warning);
|
|
if (event.toolStatus === 'failed') {
|
|
warnings.add(`Tool ${event.toolUseId} failed after changing files.`);
|
|
}
|
|
if (event.toolStatus === 'killed') {
|
|
warnings.add(`Background tool ${event.toolUseId} was killed after changing files.`);
|
|
}
|
|
}
|
|
if (options.recovered) {
|
|
warnings.add('Task change ledger recovered from malformed journal lines.');
|
|
}
|
|
return [...warnings];
|
|
}
|
|
|
|
private buildTimeline(filePath: string, snippets: SnippetDiff[]): FileEditTimeline {
|
|
const events: FileEditEvent[] = snippets.map((snippet, index) => {
|
|
const { added, removed } = this.countLineChanges(snippet.oldString, snippet.newString);
|
|
return {
|
|
toolUseId: snippet.toolUseId,
|
|
toolName: snippet.toolName,
|
|
timestamp: snippet.timestamp,
|
|
summary: this.summaryForSnippet(snippet, added, removed),
|
|
linesAdded: added,
|
|
linesRemoved: removed,
|
|
snippetIndex: index,
|
|
};
|
|
});
|
|
const firstMs = Date.parse(events[0]?.timestamp ?? '');
|
|
const lastMs = Date.parse(events[events.length - 1]?.timestamp ?? '');
|
|
return {
|
|
filePath,
|
|
events,
|
|
durationMs:
|
|
Number.isFinite(firstMs) && Number.isFinite(lastMs) ? Math.max(0, lastMs - firstMs) : 0,
|
|
};
|
|
}
|
|
|
|
private summaryForSnippet(snippet: SnippetDiff, added: number, removed: number): string {
|
|
if (snippet.type === 'write-new') return `Created file (${added} lines)`;
|
|
if (snippet.type === 'write-update') return `Rewrote file (+${added}/-${removed})`;
|
|
if (snippet.type === 'shell-snapshot') {
|
|
return `${snippet.toolName === 'PowerShell' ? 'PowerShell' : 'Shell'} changed file (+${added}/-${removed})`;
|
|
}
|
|
if (snippet.type === 'hook-snapshot') return `Hook changed file (+${added}/-${removed})`;
|
|
if (snippet.type === 'notebook-edit') return `Edited notebook (+${added}/-${removed})`;
|
|
return `Edited file (+${added}/-${removed})`;
|
|
}
|
|
|
|
private countLineChanges(before: string, after: string): { added: number; removed: number } {
|
|
let added = 0;
|
|
let removed = 0;
|
|
for (const change of diffLines(before, after)) {
|
|
if (change.added) added += change.count ?? 0;
|
|
if (change.removed) removed += change.count ?? 0;
|
|
}
|
|
return { added, removed };
|
|
}
|
|
|
|
private groupKeyForSnippet(snippet: SnippetDiff): string {
|
|
return this.groupKeyForFileSummary(snippet.filePath, snippet.ledger?.relation);
|
|
}
|
|
|
|
private groupKeyForFileSummary(filePath: string, relation?: LedgerChangeRelation): string {
|
|
if (relation) {
|
|
return `${relation.kind}:${normalizePathForComparison(relation.oldPath)}->${normalizePathForComparison(relation.newPath)}`;
|
|
}
|
|
return `path:${normalizePathForComparison(filePath)}`;
|
|
}
|
|
|
|
private relationForSnippets(snippets: SnippetDiff[]): LedgerChangeRelation | undefined {
|
|
return snippets.find((snippet) => snippet.ledger?.relation)?.ledger?.relation;
|
|
}
|
|
|
|
private resolveGroupedDisplayPath(
|
|
fallbackPath: string,
|
|
relation: LedgerChangeRelation | undefined,
|
|
snippets: SnippetDiff[]
|
|
): string {
|
|
if (!relation) {
|
|
return fallbackPath;
|
|
}
|
|
|
|
const newPathSnippet = snippets.find((snippet) =>
|
|
this.pathMatchesRelationPath(snippet.filePath, relation.newPath)
|
|
);
|
|
if (newPathSnippet) {
|
|
return newPathSnippet.filePath;
|
|
}
|
|
|
|
const createdSnippet = snippets.find(
|
|
(snippet) => snippet.ledger?.operation === 'create' || snippet.type === 'write-new'
|
|
);
|
|
if (createdSnippet) {
|
|
return createdSnippet.filePath;
|
|
}
|
|
|
|
return (
|
|
this.resolveRelatedPathFromRelation(fallbackPath, relation.oldPath, relation.newPath) ??
|
|
fallbackPath
|
|
);
|
|
}
|
|
|
|
private pathMatchesRelationPath(filePath: string, relationPath: string): boolean {
|
|
const normalizedFilePath = filePath.replace(/\\/g, '/');
|
|
const normalizedRelationPath = relationPath.replace(/\\/g, '/');
|
|
return (
|
|
normalizedFilePath === normalizedRelationPath ||
|
|
normalizedFilePath.endsWith(`/${normalizedRelationPath}`)
|
|
);
|
|
}
|
|
|
|
private resolveRelatedPathFromRelation(
|
|
anchorPath: string,
|
|
anchorRelationPath: string,
|
|
targetRelationPath: string
|
|
): string | null {
|
|
const normalizedAnchor = anchorPath.replace(/\\/g, '/');
|
|
const normalizedAnchorRelation = anchorRelationPath.replace(/\\/g, '/');
|
|
if (!normalizedAnchor.endsWith(normalizedAnchorRelation)) {
|
|
return null;
|
|
}
|
|
|
|
return this.normalizeLedgerFilePath(
|
|
`${normalizedAnchor.slice(0, normalizedAnchor.length - normalizedAnchorRelation.length)}${targetRelationPath.replace(/\\/g, '/')}`
|
|
);
|
|
}
|
|
|
|
private normalizeLedgerFilePath(filePath: string): string {
|
|
const slashPath = filePath.replace(/\\/g, '/');
|
|
const isWindowsAbsolute = /^[A-Za-z]:\//.test(slashPath) || slashPath.startsWith('//');
|
|
if (isWindowsAbsolute || (process.platform !== 'win32' && path.isAbsolute(filePath))) {
|
|
return path.normalize(filePath);
|
|
}
|
|
return slashPath;
|
|
}
|
|
|
|
private relativePath(
|
|
filePath: string,
|
|
projectPath?: string,
|
|
explicitRelativePath?: string
|
|
): string {
|
|
if (explicitRelativePath) {
|
|
return explicitRelativePath.replace(/\\/g, '/');
|
|
}
|
|
const normalizedFilePath = filePath.replace(/\\/g, '/');
|
|
const normalizedProjectPath = projectPath?.replace(/\\/g, '/');
|
|
const comparableFilePath = normalizePathForComparison(normalizedFilePath);
|
|
const comparableProjectPath = normalizedProjectPath
|
|
? normalizePathForComparison(normalizedProjectPath)
|
|
: undefined;
|
|
if (
|
|
normalizedProjectPath &&
|
|
comparableProjectPath &&
|
|
comparableFilePath.startsWith(`${comparableProjectPath}/`)
|
|
) {
|
|
return normalizedFilePath.slice(normalizedProjectPath.length + 1);
|
|
}
|
|
return normalizedFilePath.split('/').slice(-3).join('/');
|
|
}
|
|
}
|