@resolveio/server-lib 22.3.126 → 22.3.127

package/src/util/ai-run-evidence-adapters.ts

@@ -1,521 +0,0 @@
-import {
-	AIRun,
-	AIRunCost,
-	AIRunEvent,
-	AIQaArtifact,
-	AIQaBusinessAssertion,
-	AIQaCompileResult,
-	AIQaInfraCheck,
-	AIQaRouteProbe,
-	buildAIRun,
-	buildAIRunCost,
-	buildAIQaRun,
-	normalizeOpenAIUsageRowsForCosting
-} from './ai-run-evidence';
-
-export interface SupportAIRunAdapterInput {
-	ticket?: Record<string, any>;
-	job?: Record<string, any>;
-	versions?: Array<Record<string, any>>;
-	buildPlans?: Array<Record<string, any>>;
-	aiJobs?: Array<Record<string, any>>;
-	taskEvents?: Array<Record<string, any>>;
-	usageLedger?: Array<Record<string, any>>;
-	commits?: Array<Record<string, any>>;
-	qaEvidence?: Record<string, any>;
-	now?: Date | string;
-}
-
-export interface AICoderAIRunAdapterInput {
-	app?: Record<string, any>;
-	job?: Record<string, any>;
-	logs?: Array<Record<string, any>>;
-	usageLedger?: Array<Record<string, any>>;
-	commits?: Array<Record<string, any>>;
-	qaEvidence?: Record<string, any>;
-	now?: Date | string;
-}
-
-export interface AssistantAIRunAdapterInput {
-	conversation?: Record<string, any>;
-	messages?: Array<Record<string, any>>;
-	issueReports?: Array<Record<string, any>>;
-	usageLedger?: Array<Record<string, any>>;
-	correctnessChecks?: Array<Record<string, any>>;
-	now?: Date | string;
-}
-
-function cleanText(value: any, max = 1000): string {
-	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
-}
-
-function idText(value: any, max = 160): string | undefined {
-	const normalized = cleanText(value, max);
-	return normalized || undefined;
-}
-
-function asArray<T = any>(value: any): T[] {
-	return Array.isArray(value) ? value : [];
-}
-
-function firstText(source: Record<string, any> | undefined, fields: string[], max = 1000): string | undefined {
-	for (const field of fields) {
-		const value = source?.[field];
-		const normalized = idText(value, max);
-		if (normalized) {
-			return normalized;
-		}
-	}
-	return undefined;
-}
-
-function dateValue(source: Record<string, any> | undefined, fields: string[]): Date | string | undefined {
-	for (const field of fields) {
-		const value = source?.[field];
-		if (value) {
-			return value;
-		}
-	}
-	return undefined;
-}
-
-function addSourceId(sourceIds: Record<string, string>, key: string, value: any): void {
-	const normalized = idText(value);
-	if (normalized) {
-		sourceIds[key] = normalized;
-	}
-}
-
-function pushEvent(events: AIRunEvent[], event: AIRunEvent): void {
-	const message = cleanText(event.message, 1800);
-	const metadata = event.metadata || {};
-	if (!message && !Object.keys(metadata).length && !event.artifactPaths?.length) {
-		return;
-	}
-	events.push({
-		...event,
-		message,
-		artifactPaths: asArray<string>(event.artifactPaths).filter(Boolean).slice(0, 20)
-	});
-}
-
-function eventDate(record: Record<string, any>): Date | string | undefined {
-	return dateValue(record, ['recordedAt', 'createdAt', 'updatedAt', 'timestamp', 'time', 'date']);
-}
-
-function collectUsageEvents(entries: Array<Record<string, any>>, events: AIRunEvent[]): AIRunCost | undefined {
-	if (!entries.length) {
-		return undefined;
-	}
-	const normalizedEntries = normalizeOpenAIUsageRowsForCosting(entries);
-	for (const entry of normalizedEntries) {
-		pushEvent(events, {
-			type: 'usage',
-			category: cleanText(entry.category || entry.kind || entry.phase, 160) || 'usage',
-			message: cleanText(entry.summary || entry.description || entry.model || 'Model usage recorded.', 800),
-			recordedAt: eventDate(entry),
-			metadata: {
-				model: entry.model,
-				inputTokens: entry.inputTokens ?? entry.input_tokens,
-				outputTokens: entry.outputTokens ?? entry.output_tokens,
-				totalTokens: entry.totalTokens ?? entry.total_tokens,
-				estimatedUsd: entry.estimatedUsd ?? entry.cost_estimate
-			}
-		});
-	}
-	return buildAIRunCost(entries);
-}
-
-function collectCommitEvents(commits: Array<Record<string, any>>, events: AIRunEvent[]): void {
-	for (const commit of commits.slice(0, 80)) {
-		pushEvent(events, {
-			type: 'git_commit',
-			message: cleanText(commit.message || commit.subject || commit.title || commit.hash || commit.sha, 1200),
-			recordedAt: eventDate(commit),
-			metadata: {
-				sha: commit.sha || commit.hash,
-				branch: commit.branch,
-				author: commit.author
-			}
-		});
-	}
-}
-
-function statusFromBoolean(value: any, fallback?: string): string | undefined {
-	if (value === true) {
-		return 'pass';
-	}
-	if (value === false) {
-		return 'fail';
-	}
-	return fallback;
-}
-
-function collectArtifacts(evidence: Record<string, any> | undefined): AIQaArtifact[] {
-	const artifacts: AIQaArtifact[] = [];
-	for (const entry of asArray<any>(evidence?.artifacts)) {
-		artifacts.push({
-			type: entry.type || 'other',
-			path: cleanText(entry.path || entry.file || entry.artifactPath, 500),
-			url: cleanText(entry.url, 500),
-			title: cleanText(entry.title || entry.name, 300),
-			caption: cleanText(entry.caption || entry.message, 800),
-			metadata: entry.metadata
-		});
-	}
-	const screenshots = asArray<any>(evidence?.screenshots || evidence?.qaScreenshots || evidence?.browserScreenshots);
-	for (const screenshot of screenshots.slice(0, 40)) {
-		if (typeof screenshot === 'string') {
-			artifacts.push({ type: 'screenshot', path: screenshot });
-		} else {
-			artifacts.push({
-				type: 'screenshot',
-				path: cleanText(screenshot.path || screenshot.file, 500),
-				url: cleanText(screenshot.url, 500),
-				title: cleanText(screenshot.title || screenshot.route, 300),
-				caption: cleanText(screenshot.caption || screenshot.message, 800),
-				metadata: screenshot.metadata
-			});
-		}
-	}
-	return artifacts;
-}
-
-function collectInfraChecks(evidence: Record<string, any> | undefined): AIQaInfraCheck[] {
-	const checks: AIQaInfraCheck[] = [];
-	for (const entry of asArray<any>(evidence?.infraChecks || evidence?.preflightChecks)) {
-		checks.push({
-			name: cleanText(entry.name || entry.check || entry.key, 160) || 'infra_check',
-			status: entry.status || statusFromBoolean(entry.passed),
-			message: cleanText(entry.message || entry.error || entry.reason, 1000),
-			path: cleanText(entry.path, 500),
-			durationMs: Number(entry.durationMs ?? entry.duration_ms) || undefined,
-			metadata: entry.metadata,
-			checkedAt: eventDate(entry)
-		});
-	}
-	if (evidence?.preflightStatus) {
-		checks.push({
-			name: 'qa_preflight',
-			status: evidence.preflightStatus,
-			message: cleanText(evidence.preflightMessage || evidence.preflightReason, 1000),
-			path: cleanText(evidence.preflightArtifactPath || evidence.preflightPath, 500)
-		});
-	}
-	return checks;
-}
-
-function collectCompileResult(evidence: Record<string, any> | undefined): AIQaCompileResult | undefined {
-	const build = evidence?.compile || evidence?.build || evidence?.buildEvidence || evidence?.buildResult;
-	if (!build && evidence?.compileStatus === undefined && evidence?.buildStatus === undefined) {
-		return undefined;
-	}
-	const status = build?.status
-		|| evidence?.compileStatus
-		|| evidence?.buildStatus
-		|| statusFromBoolean(build?.passed ?? build?.allExpectedPassed ?? evidence?.buildPassed);
-	return {
-		status,
-		command: cleanText(build?.command || evidence?.buildCommand, 500),
-		artifactPath: cleanText(build?.artifactPath || build?.logPath || evidence?.buildLogPath, 500),
-		message: cleanText(build?.message || build?.error || evidence?.buildMessage, 1000),
-		durationMs: Number(build?.durationMs ?? build?.duration_ms) || undefined,
-		staleEvidence: build?.staleEvidence === true || evidence?.staleBuildEvidence === true,
-		recordedAt: eventDate(build || evidence || {})
-	};
-}
-
-function collectRouteProbes(evidence: Record<string, any> | undefined): AIQaRouteProbe[] {
-	const probes: AIQaRouteProbe[] = [];
-	for (const entry of asArray<any>(evidence?.routeProbes || evidence?.routes || evidence?.browserRoutes)) {
-		probes.push({
-			route: cleanText(entry.route || entry.path || entry.url, 500) || '/',
-			status: entry.status || statusFromBoolean(entry.passed),
-			screenshot: cleanText(entry.screenshot || entry.screenshotPath, 500),
-			caption: cleanText(entry.caption || entry.message, 1000),
-			shellOnly: entry.shellOnly === true,
-			authenticated: entry.authenticated === true,
-			consoleErrors: asArray<string>(entry.consoleErrors),
-			networkErrors: asArray<string>(entry.networkErrors),
-			message: cleanText(entry.message || entry.error, 1000),
-			recordedAt: eventDate(entry)
-		});
-	}
-	const screenshots = asArray<any>(evidence?.screenshots || evidence?.qaScreenshots || evidence?.browserScreenshots);
-	for (const screenshot of screenshots.slice(0, 20)) {
-		if (typeof screenshot === 'string') {
-			probes.push({ route: '/', status: 'pass', screenshot, caption: 'Historical browser screenshot recorded.' });
-		} else if (screenshot.route || screenshot.path || screenshot.url || screenshot.screenshot || screenshot.file) {
-			probes.push({
-				route: cleanText(screenshot.route || screenshot.url || screenshot.path, 500) || '/',
-				status: screenshot.status || statusFromBoolean(screenshot.passed, 'pass'),
-				screenshot: cleanText(screenshot.screenshot || screenshot.screenshotPath || screenshot.file || screenshot.path, 500),
-				caption: cleanText(screenshot.caption || screenshot.message, 1000),
-				shellOnly: screenshot.shellOnly === true,
-				authenticated: screenshot.authenticated === true,
-				recordedAt: eventDate(screenshot)
-			});
-		}
-	}
-	return probes;
-}
-
-function collectBusinessAssertions(evidence: Record<string, any> | undefined): AIQaBusinessAssertion[] {
-	const assertions: AIQaBusinessAssertion[] = [];
-	for (const entry of asArray<any>(evidence?.businessAssertions || evidence?.workflowAssertions || evidence?.assertions)) {
-		assertions.push({
-			assertion: cleanText(entry.assertion || entry.name || entry.workflow || entry.expected, 1000) || 'business assertion',
-			status: entry.status || statusFromBoolean(entry.passed),
-			workflow: cleanText(entry.workflow, 400),
-			route: cleanText(entry.route, 500),
-			action: cleanText(entry.action, 500),
-			expected: cleanText(entry.expected, 1000),
-			observed: cleanText(entry.observed || entry.actual, 1000),
-			dataProof: cleanText(entry.dataProof || entry.proof, 1400),
-			artifactPaths: asArray<string>(entry.artifactPaths || entry.artifacts),
-			message: cleanText(entry.message || entry.error || entry.reason, 1000),
-			recordedAt: eventDate(entry),
-			metadata: entry.metadata
-		});
-	}
-	if (!assertions.length && evidence?.qaRunOutcome === 'business_assertion_passed') {
-		assertions.push({
-			assertion: cleanText(evidence.aiRunOutcomeReason || evidence.reason || 'Historical business assertion passed.', 1000),
-			status: 'pass',
-			dataProof: cleanText(evidence.aiRunOutcomeReason || evidence.reason, 1400)
-		});
-	}
-	if (!assertions.length && evidence?.qaRunOutcome === 'business_assertion_failed') {
-		assertions.push({
-			assertion: cleanText(evidence.aiRunOutcomeReason || evidence.reason || 'Historical business assertion failed.', 1000),
-			status: 'fail',
-			observed: cleanText(evidence.aiRunOutcomeReason || evidence.reason, 1000)
-		});
-	}
-	return assertions;
-}
-
-function buildQaFromEvidence(evidence: Record<string, any> | undefined, now?: Date | string) {
-	return buildAIQaRun({
-		infraChecks: collectInfraChecks(evidence),
-		compile: collectCompileResult(evidence),
-		routeProbes: collectRouteProbes(evidence),
-		businessAssertions: collectBusinessAssertions(evidence),
-		artifacts: collectArtifacts(evidence),
-		now
-	});
-}
-
-function evidenceObject(...values: any[]): Record<string, any> {
-	for (const value of values) {
-		if (value && typeof value === 'object' && !Array.isArray(value)) {
-			return value;
-		}
-	}
-	return {};
-}
-
-export function buildSupportAIRunFromEvidence(input: SupportAIRunAdapterInput): AIRun {
-	const ticket = input.ticket || {};
-	const job = input.job || {};
-	const evidence = evidenceObject(input.qaEvidence, job.qaEvidence, job.qa_evidence, ticket.qaEvidence, ticket.qa_evidence);
-	const events: AIRunEvent[] = [];
-	const sourceIds: Record<string, string> = {};
-	addSourceId(sourceIds, 'ticketId', ticket._id || ticket.id || job.ticketId || job.supportTicketId);
-	addSourceId(sourceIds, 'ticketNumber', ticket.ticketNumber || ticket.number || job.ticketNumber);
-	addSourceId(sourceIds, 'jobId', job._id || job.id || job.jobId);
-	addSourceId(sourceIds, 'buildPlanId', job.buildPlanId || ticket.buildPlanId);
-
-	for (const event of asArray<Record<string, any>>(input.taskEvents)) {
-		pushEvent(events, {
-			type: event.type === 'human_intervention' ? 'human_intervention' : 'log',
-			category: cleanText(event.category || event.phase || event.type, 160),
-			message: cleanText(event.message || event.summary || event.text || event.title, 1800),
-			recordedAt: eventDate(event),
-			metadata: {
-				status: event.status,
-				phase: event.phase,
-				taskId: event.taskId || event._id || event.id
-			}
-		});
-	}
-	for (const aiJob of asArray<Record<string, any>>(input.aiJobs)) {
-		pushEvent(events, {
-			type: aiJob.model ? 'model_call' : 'log',
-			category: cleanText(aiJob.category || aiJob.phase || aiJob.runner, 160),
-			message: cleanText(aiJob.summary || aiJob.promptSummary || aiJob.status || aiJob.phase, 1800),
-			recordedAt: eventDate(aiJob),
-			metadata: {
-				id: aiJob._id || aiJob.id,
-				model: aiJob.model,
-				status: aiJob.status,
-				phase: aiJob.phase
-			}
-		});
-	}
-	collectCommitEvents(asArray<Record<string, any>>(input.commits), events);
-	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
-
-	const qa = buildQaFromEvidence(evidence, input.now);
-	return buildAIRun({
-		source: 'support_ticket',
-		sourceIds,
-		title: firstText(ticket, ['title', 'subject', 'summary']) || firstText(job, ['title', 'summary']),
-		status: firstText(job, ['status', 'state']) || firstText(ticket, ['status', 'state']),
-		phase: firstText(job, ['phase', 'runnerPhase']),
-		startedAt: dateValue(job, ['startedAt', 'createdAt']) || dateValue(ticket, ['createdAt']),
-		completedAt: dateValue(job, ['completedAt', 'finishedAt', 'updatedAt']),
-		events,
-		qa,
-		cost,
-		scorecardPassed: evidence.scorecardPassed === true || evidence.scorecardStatus === 'pass',
-		deployStatus: evidence.deployStatus,
-		publishStatus: evidence.publishStatus,
-		sampleDataStatus: evidence.sampleDataStatus,
-		manualHandoff: evidence.manualHandoff === true || job.manualHandoff === true,
-		stopped: evidence.stopped === true || job.stopped === true,
-		rejected: evidence.rejected === true,
-		explicitAccepted: evidence.explicitAccepted === true || ticket.accepted === true,
-		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${job.status || ''} ${ticket.status || ''}`),
-		now: input.now,
-		metadata: {
-			versionCount: asArray(input.versions).length,
-			buildPlanCount: asArray(input.buildPlans).length
-		}
-	});
-}
-
-export function buildAICoderAIRunFromEvidence(input: AICoderAIRunAdapterInput): AIRun {
-	const app = input.app || {};
-	const job = input.job || {};
-	const evidence = evidenceObject(input.qaEvidence, job.qaEvidence, job.qa_evidence, app.qaEvidence, app.qa_evidence);
-	const events: AIRunEvent[] = [];
-	const sourceIds: Record<string, string> = {};
-	addSourceId(sourceIds, 'appId', app._id || app.id || job.appId || job.aicoderAppId);
-	addSourceId(sourceIds, 'jobId', job._id || job.id || job.jobId);
-	addSourceId(sourceIds, 'domain', app.domain || app.customDomain || job.domain);
-
-	for (const log of asArray<Record<string, any>>(input.logs)) {
-		pushEvent(events, {
-			type: log.type === 'scorecard' ? 'scorecard' : 'log',
-			category: cleanText(log.category || log.phase || log.level, 160),
-			message: cleanText(log.message || log.summary || log.text || log.title, 1800),
-			artifactPaths: asArray<string>(log.artifactPaths || log.artifacts),
-			recordedAt: eventDate(log),
-			metadata: {
-				status: log.status,
-				level: log.level,
-				score: log.score
-			}
-		});
-	}
-	collectCommitEvents(asArray<Record<string, any>>(input.commits), events);
-	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
-	const qa = buildQaFromEvidence(evidence, input.now);
-	const scorecardPassed = evidence.scorecardPassed === true
-		|| evidence.scorecardStatus === 'pass'
-		|| (Number(evidence.score ?? evidence.qualityScore ?? 0) >= Number(evidence.scoreThreshold ?? job.scoreThreshold ?? 90));
-
-	return buildAIRun({
-		source: 'aicoder_app',
-		sourceIds,
-		title: firstText(app, ['name', 'title']) || firstText(job, ['appName', 'title', 'goal']),
-		status: firstText(job, ['status', 'state']) || firstText(app, ['status', 'state']),
-		phase: firstText(job, ['phase', 'runnerPhase']),
-		startedAt: dateValue(job, ['startedAt', 'createdAt']) || dateValue(app, ['createdAt']),
-		completedAt: dateValue(job, ['completedAt', 'finishedAt', 'updatedAt']),
-		events,
-		qa,
-		cost,
-		scorecardPassed,
-		deployStatus: evidence.deployStatus || statusFromBoolean(evidence.deployReady),
-		publishStatus: evidence.publishStatus || evidence.pullRequestStatus,
-		sampleDataStatus: evidence.sampleDataStatus || statusFromBoolean(evidence.sampleDataReady ?? evidence.hasSampleData),
-		manualHandoff: evidence.manualHandoff === true || job.manualHandoff === true,
-		stopped: evidence.stopped === true || job.stopped === true,
-		rejected: evidence.rejected === true,
-		explicitAccepted: evidence.explicitAccepted === true || app.accepted === true,
-		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${job.status || ''} ${job.phase || ''}`),
-		now: input.now,
-		metadata: {
-			domain: app.domain || app.customDomain || job.domain,
-			wowScore: evidence.wowScore ?? job.wowScore,
-			score: evidence.score ?? evidence.qualityScore
-		}
-	});
-}
-
-export function buildAssistantAIRunFromEvidence(input: AssistantAIRunAdapterInput): AIRun {
-	const conversation = input.conversation || {};
-	const events: AIRunEvent[] = [];
-	const sourceIds: Record<string, string> = {};
-	addSourceId(sourceIds, 'conversationId', conversation._id || conversation.id || conversation.conversationId);
-	addSourceId(sourceIds, 'userId', conversation.userId || conversation.ownerId);
-
-	for (const message of asArray<Record<string, any>>(input.messages)) {
-		pushEvent(events, {
-			type: 'assistant_message',
-			category: cleanText(message.role || message.authorRole || message.type, 160),
-			message: cleanText(message.content || message.text || message.message || message.summary, 1800),
-			recordedAt: eventDate(message),
-			metadata: {
-				id: message._id || message.id,
-				role: message.role,
-				model: message.model
-			}
-		});
-	}
-	for (const report of asArray<Record<string, any>>(input.issueReports)) {
-		pushEvent(events, {
-			type: 'human_intervention',
-			category: cleanText(report.category || report.status || 'issue_report', 160),
-			message: cleanText(report.summary || report.description || report.message || report.title, 1800),
-			recordedAt: eventDate(report),
-			metadata: {
-				id: report._id || report.id,
-				status: report.status,
-				severity: report.severity
-			}
-		});
-	}
-	const cost = collectUsageEvents(asArray<Record<string, any>>(input.usageLedger), events);
-	const correctnessEvidence = {
-		businessAssertions: asArray<Record<string, any>>(input.correctnessChecks).map((check) => ({
-			assertion: check.assertion || check.name || check.case || 'assistant correctness check',
-			status: check.status || statusFromBoolean(check.passed),
-			expected: check.expected,
-			observed: check.observed || check.actual,
-			dataProof: check.dataProof || check.proof,
-			artifactPaths: check.artifactPaths,
-			message: check.message || check.reason,
-			metadata: check.metadata,
-			recordedAt: eventDate(check)
-		}))
-	};
-	const qa = buildQaFromEvidence(correctnessEvidence, input.now);
-	const failedReports = asArray<Record<string, any>>(input.issueReports)
-		.filter((report) => /open|new|fail|bug|wrong|incorrect|error/i.test(`${report.status || ''} ${report.category || ''} ${report.summary || ''}`));
-
-	return buildAIRun({
-		source: 'ai_assistant',
-		sourceIds,
-		title: firstText(conversation, ['title', 'subject', 'summary']) || 'AI assistant conversation',
-		status: firstText(conversation, ['status', 'state']),
-		phase: firstText(conversation, ['phase']),
-		startedAt: dateValue(conversation, ['startedAt', 'createdAt']),
-		completedAt: dateValue(conversation, ['completedAt', 'closedAt', 'updatedAt']),
-		events,
-		qa,
-		cost,
-		rejected: failedReports.length > 0 || conversation.rejected === true,
-		manualHandoff: conversation.manualHandoff === true,
-		stopped: conversation.stopped === true,
-		explicitAccepted: conversation.accepted === true,
-		terminal: /complete|closed|resolved|done|failed|rejected/i.test(`${conversation.status || ''}`),
-		now: input.now,
-		metadata: {
-			issueReportCount: asArray(input.issueReports).length,
-			correctnessCheckCount: asArray(input.correctnessChecks).length
-		}
-	});
-}