@bbigbang/core 0.1.0

package/dist/services/missionEvidence.js

@@ -0,0 +1,377 @@
+const PREVIEW_LIMIT = 500;
+export function deriveMissionEvidence(input) {
+    const { mission } = input;
+    const evidence = [
+        ...input.events.map((event) => deriveEventEvidence(mission, event)),
+        ...input.attempts.map((attempt) => deriveAttemptEvidence(mission, attempt)),
+        ...deriveSnapshotEvidence(mission, input.snapshot),
+        ...input.features.map((feature) => deriveFeatureEvidence(mission, feature)),
+        ...input.assertions.map((assertion) => deriveAssertionEvidence(mission, assertion)),
+        ...input.interactions.map((interaction) => deriveInteractionEvidence(mission, interaction)),
+    ];
+    evidence.sort((left, right) => {
+        if (left.eventTime !== right.eventTime)
+            return left.eventTime - right.eventTime;
+        return left.evidenceId.localeCompare(right.evidenceId);
+    });
+    return evidence;
+}
+export function filterMissionEvidence(evidence, filter) {
+    let result = evidence;
+    if (filter.sourceType) {
+        result = result.filter((item) => item.sourceType === filter.sourceType);
+    }
+    if (filter.featureId) {
+        result = result.filter((item) => item.featureId === filter.featureId);
+    }
+    if (typeof filter.after === 'number' && Number.isFinite(filter.after)) {
+        const after = filter.after;
+        result = result.filter((item) => item.eventTime > after);
+    }
+    if (typeof filter.limit === 'number' && Number.isFinite(filter.limit) && filter.limit > 0) {
+        const limit = filter.limit;
+        result = result.slice(0, Math.min(limit, 1_000));
+    }
+    return result;
+}
+function deriveEventEvidence(mission, event) {
+    const sourceType = 'mission_event';
+    const roleHint = inferRoleFromEvent(event);
+    const featureId = extractFeatureId(event.payload);
+    const preview = buildEventPreview(event);
+    return {
+        evidenceId: `${sourceType}:${event.eventId}`,
+        missionId: mission.missionId,
+        runtimeProvider: mission.runtimeProvider,
+        sourceType,
+        sourceRef: event.eventId,
+        eventTime: event.eventTime,
+        roleHint,
+        payloadPreview: preview,
+        payloadJson: {
+            eventId: event.eventId,
+            eventType: event.eventType,
+            source: event.source,
+            eventTime: event.eventTime,
+            createdAt: event.createdAt,
+            payload: event.payload,
+        },
+        featureId,
+    };
+}
+function deriveAttemptEvidence(mission, attempt) {
+    const sourceType = 'mission_attempt';
+    const roleHint = 'worker';
+    const preview = buildAttemptPreview(attempt);
+    return {
+        evidenceId: `${sourceType}:${attempt.attemptId}`,
+        missionId: mission.missionId,
+        runtimeProvider: mission.runtimeProvider,
+        sourceType,
+        sourceRef: attempt.attemptId,
+        eventTime: attempt.createdAt,
+        roleHint,
+        payloadPreview: preview,
+        payloadJson: {
+            attemptId: attempt.attemptId,
+            requestId: attempt.requestId,
+            attemptType: attempt.attemptType,
+            state: attempt.state,
+            nodeId: attempt.nodeId,
+            missionDir: attempt.missionDir,
+            promptPreview: attempt.promptPreview,
+            pid: attempt.pid,
+            exitCode: attempt.exitCode,
+            signal: attempt.signal,
+            error: attempt.error,
+            stdoutEventCount: attempt.stdoutEventCount,
+            stderrEventCount: attempt.stderrEventCount,
+            outputPreview: attempt.outputPreview,
+            supersededBy: attempt.supersededBy,
+            supersessionReason: attempt.supersessionReason,
+            supersededAt: attempt.supersededAt,
+            createdAt: attempt.createdAt,
+            acceptedAt: attempt.acceptedAt,
+            completedAt: attempt.completedAt,
+        },
+        featureId: null,
+    };
+}
+function deriveSnapshotEvidence(mission, snapshot) {
+    if (!snapshot)
+        return [];
+    const sourceType = 'mission_snapshot';
+    const roleHint = 'system';
+    const baseTime = snapshot.createdAt;
+    const snapshotData = snapshot.snapshot ?? {};
+    const evidence = [];
+    evidence.push({
+        evidenceId: `${sourceType}:${snapshot.snapshotId}:overview`,
+        missionId: mission.missionId,
+        runtimeProvider: mission.runtimeProvider,
+        sourceType,
+        sourceRef: snapshot.snapshotId,
+        eventTime: baseTime,
+        roleHint,
+        payloadPreview: truncatePreview(`Snapshot overview: ${JSON.stringify(snapshotData.overview ?? {})}`),
+        payloadJson: {
+            snapshotId: snapshot.snapshotId,
+            source: snapshot.source,
+            section: 'overview',
+            overview: snapshotData.overview ?? {},
+        },
+        featureId: null,
+    });
+    const featureItems = asRecordArray(snapshotData.features?.items);
+    for (const feature of featureItems) {
+        const featureId = typeof feature.id === 'string' ? feature.id : null;
+        evidence.push({
+            evidenceId: `${sourceType}:${snapshot.snapshotId}:feature:${featureId ?? evidence.length}`,
+            missionId: mission.missionId,
+            runtimeProvider: mission.runtimeProvider,
+            sourceType,
+            sourceRef: snapshot.snapshotId,
+            eventTime: baseTime,
+            roleHint,
+            payloadPreview: truncatePreview(`Feature [${feature.status ?? 'unknown'}]: ${feature.description ?? ''}`),
+            payloadJson: {
+                snapshotId: snapshot.snapshotId,
+                source: snapshot.source,
+                section: 'feature',
+                feature,
+            },
+            featureId,
+        });
+    }
+    const handoffItems = asRecordArray(snapshotData.handoffs?.items);
+    for (const handoff of handoffItems) {
+        const featureId = typeof handoff.featureId === 'string' ? handoff.featureId : null;
+        const summary = typeof handoff.salientSummary === 'string' ? handoff.salientSummary : '';
+        evidence.push({
+            evidenceId: `${sourceType}:${snapshot.snapshotId}:handoff:${featureId ?? evidence.length}`,
+            missionId: mission.missionId,
+            runtimeProvider: mission.runtimeProvider,
+            sourceType,
+            sourceRef: snapshot.snapshotId,
+            eventTime: baseTime,
+            roleHint,
+            payloadPreview: truncatePreview(`Handoff: ${summary}`),
+            payloadJson: {
+                snapshotId: snapshot.snapshotId,
+                source: snapshot.source,
+                section: 'handoff',
+                handoff,
+            },
+            featureId,
+        });
+    }
+    const assertionItems = asRecordArray(snapshotData.validation?.assertions);
+    for (const assertion of assertionItems) {
+        const featureId = typeof assertion.featureId === 'string' ? assertion.featureId : null;
+        const raw = asPlainObject(assertion.raw);
+        const text = typeof raw.assertionText === 'string' ? raw.assertionText : '';
+        evidence.push({
+            evidenceId: `${sourceType}:${snapshot.snapshotId}:assertion:${featureId ?? evidence.length}`,
+            missionId: mission.missionId,
+            runtimeProvider: mission.runtimeProvider,
+            sourceType,
+            sourceRef: snapshot.snapshotId,
+            eventTime: baseTime,
+            roleHint: 'validator',
+            payloadPreview: truncatePreview(`Assertion [${assertion.status ?? 'unknown'}]: ${text}`),
+            payloadJson: {
+                snapshotId: snapshot.snapshotId,
+                source: snapshot.source,
+                section: 'assertion',
+                assertion,
+            },
+            featureId,
+        });
+    }
+    const reportItems = asRecordArray(snapshotData.artifacts?.reports);
+    for (const report of reportItems) {
+        const reportPath = typeof report.path === 'string' ? report.path : '';
+        evidence.push({
+            evidenceId: `${sourceType}:${snapshot.snapshotId}:report:${reportPath || evidence.length}`,
+            missionId: mission.missionId,
+            runtimeProvider: mission.runtimeProvider,
+            sourceType,
+            sourceRef: snapshot.snapshotId,
+            eventTime: baseTime,
+            roleHint,
+            payloadPreview: truncatePreview(`Report: ${reportPath}`),
+            payloadJson: {
+                snapshotId: snapshot.snapshotId,
+                source: snapshot.source,
+                section: 'report',
+                report,
+            },
+            featureId: null,
+        });
+    }
+    return evidence;
+}
+function deriveFeatureEvidence(mission, feature) {
+    const sourceType = 'mission_feature';
+    const roleHint = 'worker';
+    return {
+        evidenceId: `${sourceType}:${feature.featureId}`,
+        missionId: mission.missionId,
+        runtimeProvider: mission.runtimeProvider,
+        sourceType,
+        sourceRef: feature.featureId,
+        eventTime: feature.createdAt,
+        roleHint,
+        payloadPreview: truncatePreview(`Feature [${feature.status}]: ${feature.description}`),
+        payloadJson: {
+            featureId: feature.featureId,
+            milestone: feature.milestone,
+            description: feature.description,
+            skillName: feature.skillName,
+            status: feature.status,
+            ordering: feature.ordering,
+            preconditions: feature.preconditions,
+            expectedBehavior: feature.expectedBehavior,
+            handoff: feature.handoff ?? null,
+            createdAt: feature.createdAt,
+            updatedAt: feature.updatedAt,
+        },
+        featureId: feature.featureId,
+    };
+}
+function deriveAssertionEvidence(mission, assertion) {
+    const sourceType = 'mission_assertion';
+    const roleHint = 'validator';
+    return {
+        evidenceId: `${sourceType}:${assertion.assertionId}`,
+        missionId: mission.missionId,
+        runtimeProvider: mission.runtimeProvider,
+        sourceType,
+        sourceRef: assertion.assertionId,
+        eventTime: assertion.createdAt,
+        roleHint,
+        payloadPreview: truncatePreview(`Assertion [${assertion.status}]: ${assertion.assertionText}`),
+        payloadJson: {
+            assertionId: assertion.assertionId,
+            featureId: assertion.featureId,
+            assertionText: assertion.assertionText,
+            status: assertion.status,
+            note: assertion.note,
+            evidence: assertion.evidence,
+            createdAt: assertion.createdAt,
+            updatedAt: assertion.updatedAt,
+        },
+        featureId: assertion.featureId,
+    };
+}
+function deriveInteractionEvidence(mission, interaction) {
+    const sourceType = 'mission_interaction';
+    const roleHint = 'user';
+    return {
+        evidenceId: `${sourceType}:${interaction.interactionId}`,
+        missionId: mission.missionId,
+        runtimeProvider: mission.runtimeProvider,
+        sourceType,
+        sourceRef: interaction.interactionId,
+        eventTime: interaction.createdAt,
+        roleHint,
+        payloadPreview: truncatePreview(`Interaction [${interaction.status}]: ${interaction.prompt}`),
+        payloadJson: {
+            interactionId: interaction.interactionId,
+            prompt: interaction.prompt,
+            status: interaction.status,
+            position: interaction.position,
+            createdAt: interaction.createdAt,
+            updatedAt: interaction.updatedAt,
+        },
+        featureId: null,
+    };
+}
+function inferRoleFromEvent(event) {
+    const type = event.eventType;
+    const source = event.source;
+    if (type.includes('validation'))
+        return 'validator';
+    if (type === 'mission_interaction_observed' || type === 'mission_interaction_applied')
+        return 'orchestrator';
+    if (type.startsWith('feature_')
+        || type.includes('worker')
+        || type === 'mission_stdout'
+        || type === 'mission_stderr'
+        || type === 'mission_worker_transcript') {
+        return 'worker';
+    }
+    if (type.includes('interaction') || type.includes('continue'))
+        return 'user';
+    if (type.startsWith('mission_')) {
+        if (type === 'mission_created' || type === 'mission_updated')
+            return 'system';
+        return 'orchestrator';
+    }
+    if (source === 'droid_cli')
+        return 'worker';
+    if (source === 'agent_node')
+        return 'worker';
+    if (source === 'platform')
+        return 'system';
+    return 'unknown';
+}
+function extractFeatureId(payload) {
+    if (!payload)
+        return null;
+    const value = payload.featureId;
+    return typeof value === 'string' ? value : null;
+}
+function buildEventPreview(event) {
+    const payload = event.payload ?? {};
+    let extra = '';
+    if (event.eventType === 'mission_stdout' || event.eventType === 'mission_stderr') {
+        const text = typeof payload.text === 'string' ? payload.text : '';
+        extra = text;
+    }
+    else if (event.eventType === 'mission_worker_transcript') {
+        const toolName = typeof payload.toolName === 'string' ? payload.toolName : 'unknown';
+        const kind = typeof payload.kind === 'string' ? payload.kind : 'transcript';
+        const content = typeof payload.content === 'string' ? payload.content : '';
+        extra = `[${kind}] ${toolName}: ${content}`;
+    }
+    else if (typeof payload.prompt === 'string' && payload.prompt) {
+        extra = payload.prompt;
+    }
+    else if (typeof payload.error === 'string' && payload.error) {
+        extra = payload.error;
+    }
+    else if (typeof payload.reason === 'string' && payload.reason) {
+        extra = payload.reason;
+    }
+    const base = `${event.eventType} (${event.source})`;
+    if (!extra)
+        return base;
+    return truncatePreview(`${base}: ${extra}`);
+}
+function buildAttemptPreview(attempt) {
+    const parts = [`${attempt.attemptType} attempt [${attempt.state}]`];
+    if (attempt.promptPreview)
+        parts.push(attempt.promptPreview);
+    if (attempt.outputPreview)
+        parts.push(attempt.outputPreview);
+    if (attempt.error)
+        parts.push(`error: ${attempt.error}`);
+    return truncatePreview(parts.join(' | '));
+}
+function truncatePreview(value, limit = PREVIEW_LIMIT) {
+    const collapsed = value.replace(/\s+/g, ' ').trim();
+    if (collapsed.length <= limit)
+        return collapsed;
+    return `${collapsed.slice(0, limit)}...`;
+}
+function asPlainObject(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value))
+        return value;
+    return {};
+}
+function asRecordArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => item != null && typeof item === 'object' && !Array.isArray(item));
+}