Assessor_2.0/outputs/dummy-result-count-audit.mjs

// Read-only reconciliation. Every live request is scoped to the explicitly authorized Dummy project.
import { createServer } from 'vite';

const projectId = 'project-7cbcb7ad';
const base = 'http://127.0.0.1:4173/api/v1';
const requests = [];
async function get(path) {
  requests.push(path);
  const response = await fetch(base + path, { signal: AbortSignal.timeout(60000) });
  if (!response.ok) throw new Error(`Read failed: ${response.status} ${path}`);
  return response.json();
}
const project = await get(`/projects/${projectId}`);
if (project.name !== 'Dummy') throw new Error('Refusing a project other than Dummy');
const [evaluations, overview, resultRows, observations] = await Promise.all([
  get(`/projects/${projectId}/policy-evaluations`),
  get(`/projects/${projectId}/policy-analysis-overview`),
  get(`/results?projectId=${projectId}&sourceTool=GPOs&limit=10000`),
  get(`/results?projectId=${projectId}&sourceKind=policy-observation&audience=internal-analysis&limit=10000`)
]);
if (resultRows.total !== resultRows.items.length || observations.total !== observations.items.length) throw new Error('Incomplete page');
const counts = (items, key) => Object.fromEntries([...Map.groupBy(items, key)].map(([value, group]) => [value, group.length]));
const vite = await createServer({ configFile: false, appType: 'custom', server: { middlewareMode: true, hmr: false, watch: null } });
try {
  const { currentPolicyEvaluationsForWork } = await vite.ssrLoadModule('/src/features/project-import/load-canonical-project-workspace.ts');
  const { appendPolicyObservationsToDataset } = await vite.ssrLoadModule('/src/features/project-import/policy-observations-to-dataset.ts');
  const { createPolicyEvaluationUnifiedResult } = await vite.ssrLoadModule('/src/domain/unified-result.ts');
  const { genericProfile } = await vite.ssrLoadModule('/src/profiles/generic/generic-profile.ts');
  const { filterAndSortRecords } = await vite.ssrLoadModule('/src/features/search-filter/filter-records.ts');
  const workRuns = currentPolicyEvaluationsForWork(evaluations.records,
    new Set(observations.items.map(item => item.sourceResultId)), new Set(overview.current.evaluationRunIds));
  const dataset = appendPolicyObservationsToDataset(null, 'Dummy', observations.items, workRuns);
  const workRecords = dataset.sheets[0].analysis.records;
  const field = (record, label) => record.fields.find(item => item.label === label)?.value ?? '';
  const dbFails = resultRows.items.filter(item => item.isDeviation);
  const workFails = workRecords.filter(item => field(item, 'Status') === 'Fail');
  const filteredWork = filterAndSortRecords(dataset.sheets[0], { activeProfile: genericProfile, dataset,
    search: '', sortColumn: 'all', sortDirection: 'asc', statusFilter: 'deviation', facetFilters: {}, actionOnly: false, reviews: {} });
  const hiddenFails = workFails.filter(item => !filteredWork.includes(item));
  const failsByIdentity = Map.groupBy(dbFails, item => item.policyIdentityKey);
  const workFailIds = new Set(workFails.map(item => field(item, 'Technical Identity')));
  const unique = items => [...new Set(items)];
  const pair = item => JSON.stringify([item.identity?.id ?? item.policyIdentityKey, item.baselineId ?? item.policyBaselineId]);
  const newFails = workRuns.flatMap(record => record.results.filter(item => createPolicyEvaluationUnifiedResult(record.run, item).isDeviation));
  const oldPairs = new Set(dbFails.map(pair));
  const newPairs = new Set(newFails.map(pair));
  const summaryRun = record => ({ id: record.run.id, aggregation: record.run.aggregationRunId,
    engine: record.run.evaluator.version, completedAt: record.run.completedAt, results: record.results.length,
    analysisCount: record.run.baselineAnalysisIds.length,
    packages: unique(record.results.map(item => item.baselineId)).length,
    failComparisons: record.results.filter(item => createPolicyEvaluationUnifiedResult(record.run, item).isDeviation).length });
  console.log(JSON.stringify({ capturedAt: new Date().toISOString(), projectId,
    observationCount: observations.total, observationAssessments: counts(observations.items, item => item.assessmentId),
    resultDb: { total: resultRows.total, classifications: counts(resultRows.items, item => item.policyClassification),
      failRows: dbFails.length, failIdentities: failsByIdentity.size,
      failRuns: counts(dbFails, item => item.evaluationRunId), failAssessments: counts(dbFails, item => item.assessmentId) },
    work: { rows: workRecords.length, statuses: counts(workRecords, item => field(item, 'Status')),
      actualDeviationFilterCount: filteredWork.length,
      actualStatusFilterCounts: Object.fromEntries(['deviation', 'passed', 'not-configured', 'no-baseline-rule', 'not-comparable', 'conflicts', 'duplicates']
        .map(status => [status, workRecords.filter(record => genericProfile.matchesStatus(record, status)).length])),
      conflicts: workRecords.filter(item => field(item, 'Conflict')).length,
      duplicates: workRecords.filter(item => field(item, 'Duplicates')).length,
      selectedRuns: workRuns.map(summaryRun) },
    relevantRuns: evaluations.records.filter(record => workRuns.some(current => current.run.aggregationRunId === record.run.aggregationRunId)).map(summaryRun),
    reconciliation: { missingFromWork: unique(dbFails.filter(item => !workFailIds.has(item.policyIdentityKey)).map(item => item.policyIdentityKey)),
      missingFromResultDb: [...workFailIds].filter(id => !failsByIdentity.has(id)),
      uniqueOldFailPairs: oldPairs.size, uniqueNewFailPairs: newPairs.size,
      excessOldFailComparisons: dbFails.length - oldPairs.size,
      oldOnlyPairs: [...oldPairs].filter(key => !newPairs.has(key)), newOnlyPairs: [...newPairs].filter(key => !oldPairs.has(key)),
      hiddenFailSettings: hiddenFails.map(record => ({ title: record.title, status: field(record, 'Status'), configured: field(record, 'Configured Value'),
        identity: field(record, 'Technical Identity'),
        comparisons: newFails.filter(item => item.identity.id === field(record, 'Technical Identity')).map(item => ({
          baseline: item.baselineLabel, customerState: item.customerState, classification: item.classification,
          baselineValue: item.comparator.baseline, decision: item.baselineVariantAssessment?.decision,
          variants: item.baselineVariantAssessment?.variants.map(variant => ({ expected: variant.comparator.baseline, relation: variant.comparator.relation })) })) })),
      settings: workFails.map(record => {
        const identity = field(record, 'Technical Identity');
        const rows = failsByIdentity.get(identity) ?? [];
        const comparisons = evaluations.records.flatMap(evaluation => evaluation.results
          .filter(item => rows.some(row => row.sourceResultId === item.id)));
        const combinations = Map.groupBy(comparisons, item => item.baselineId);
        return { title: record.title, identity, resultDbRows: rows.length,
          distinctPackages: unique(rows.map(item => item.policyBaselineId)).length,
          repeatedPackages: [...combinations].filter(([, items]) => items.length > 1).map(([, items]) => ({
            baseline: items[0].baselineLabel, comparisons: items.length,
            analysisVersions: unique(items.map(item => item.baselineAnalysisId)).length })) };
      }) }, requests }, null, 2));
} finally { await vite.close(); }