@mcoda/codali 0.1.90 → 0.1.91

package/dist/improvement/DatasetEligibilityGate.d.ts

@@ -0,0 +1,75 @@
+import { type CodaliStorageExportKind, type CodaliStorageExportManifest, type CodaliStorageObjectRef } from "../storage/CodaliStorageContracts.js";
+export declare const CODALI_IMPROVEMENT_ELIGIBILITY_GATE_SCHEMA_VERSION: "codali.improvement.eligibility_gate.v1";
+export type DatasetEligibilityGateReasonCode = "artifact_privacy_read_disallowed" | "artifact_type_missing" | "artifact_type_not_allowed" | "deletion_group_revoked" | "duplicate_lineage" | "privacy_metadata_missing" | "row_invalid" | "row_privacy_read_disallowed";
+export type DatasetEligibilityGateWarningCode = "artifact_payload_read_blocked" | "duplicate_lineage_dropped" | "lineage_revoked" | "no_accepted_examples";
+export type DatasetEligibilityGatePreferenceSignal = "human_reviewed" | "accepted_correction" | "high_confidence" | "strong_negative";
+export interface DatasetEligibilityGateReason {
+    code: DatasetEligibilityGateReasonCode;
+    message: string;
+    path?: string;
+    details?: Record<string, unknown>;
+}
+export interface DatasetEligibilityGateWarning {
+    code: DatasetEligibilityGateWarningCode;
+    message: string;
+    recordId?: string;
+    dedupeKey?: string;
+    details?: Record<string, unknown>;
+}
+export interface DatasetEligibilityGateAcceptedExample {
+    recordId: string;
+    sourceGatewayRecordId?: string;
+    dedupeKey: string;
+    lineageKey: DatasetEligibilityLineageKey;
+    deletionGroupIds: string[];
+    runIds: string[];
+    artifactTypes: string[];
+    preferenceSignals: DatasetEligibilityGatePreferenceSignal[];
+    priorityScore: number;
+}
+export interface DatasetEligibilityGateRejectedExample {
+    targetType: "artifact" | "example";
+    recordId?: string;
+    dedupeKey?: string;
+    reasons: DatasetEligibilityGateReason[];
+}
+export interface DatasetEligibilityGateReport {
+    schemaVersion: typeof CODALI_IMPROVEMENT_ELIGIBILITY_GATE_SCHEMA_VERSION;
+    exportId: string;
+    manifestId: string;
+    exportKind: CodaliStorageExportKind;
+    artifactReadAllowed: boolean;
+    lineageValid: boolean;
+    totalExamples: number;
+    acceptedCount: number;
+    rejectedCount: number;
+    warningCount: number;
+    acceptedRecordIds: string[];
+    rejectedRecordIds: string[];
+    reasonCounts: Record<string, number>;
+    accepted: DatasetEligibilityGateAcceptedExample[];
+    rejected: DatasetEligibilityGateRejectedExample[];
+    warnings: DatasetEligibilityGateWarning[];
+}
+export interface DatasetEligibilityLineageKey {
+    runIds: string[];
+    deletionGroupIds: string[];
+    taskHash?: string;
+    promptHash?: string;
+    toolContractHash?: string;
+    expectedTargetHash?: string;
+}
+export interface DatasetEligibilityGateInput {
+    exportId?: string;
+    manifest: CodaliStorageExportManifest;
+    primaryArtifactRef: CodaliStorageObjectRef;
+    rows?: readonly unknown[];
+    allowedArtifactTypes?: readonly string[];
+    revokedDeletionGroupIds?: readonly string[];
+}
+export declare const evaluateDatasetExportArtifactPayloadRead: (manifest: CodaliStorageExportManifest, primaryArtifactRef: CodaliStorageObjectRef) => DatasetEligibilityGateReason[];
+export declare class DatasetEligibilityGate {
+    curate(input: DatasetEligibilityGateInput): DatasetEligibilityGateReport;
+}
+export declare const curateDatasetExportForImprovement: (input: DatasetEligibilityGateInput) => DatasetEligibilityGateReport;
+//# sourceMappingURL=DatasetEligibilityGate.d.ts.map

package/dist/improvement/DatasetEligibilityGate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatasetEligibilityGate.d.ts","sourceRoot":"","sources":["../../src/improvement/DatasetEligibilityGate.ts"],"names":[],"mappings":"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"}

package/dist/improvement/DatasetEligibilityGate.js

@@ -0,0 +1,497 @@
+import { createHash } from "node:crypto";
+import { evaluateCodaliDatasetObjectPayloadRead, } from "../storage/CodaliDatasetPrivacyEngine.js";
+export const CODALI_IMPROVEMENT_ELIGIBILITY_GATE_SCHEMA_VERSION = "codali.improvement.eligibility_gate.v1";
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const sha256Hex = (input) => createHash("sha256").update(input).digest("hex");
+const uniqueSorted = (values) => Array.from(new Set(values
+    .map((value) => value?.trim())
+    .filter((value) => Boolean(value))))
+    .sort();
+const normalizeToken = (value) => value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+const readString = (record, keys) => {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === "string" && value.trim())
+            return value.trim();
+    }
+    return undefined;
+};
+const readBoolean = (record, keys) => {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === "boolean")
+            return value;
+    }
+    return undefined;
+};
+const readNumber = (record, keys) => {
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            return value;
+        if (typeof value === "string" && value.trim() && Number.isFinite(Number(value))) {
+            return Number(value);
+        }
+    }
+    return undefined;
+};
+const stringList = (value) => {
+    if (Array.isArray(value)) {
+        return uniqueSorted(value.map((entry) => typeof entry === "string" ? entry : undefined));
+    }
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    return [];
+};
+const recordList = (value) => Array.isArray(value) ? value.filter(isRecord) : [];
+const refRecord = (value) => isRecord(value) &&
+    typeof value.refId === "string" &&
+    typeof value.contentHash === "string" &&
+    typeof value.deletionGroupId === "string" &&
+    isRecord(value.privacyFlags)
+    ? value
+    : undefined;
+const refsForExample = (record) => {
+    const refs = [
+        refRecord(record.inputRef),
+        refRecord(record.outputRef),
+        ...recordList(record.evidenceRefs).map((entry) => refRecord(entry)),
+    ];
+    return refs.filter((ref) => Boolean(ref));
+};
+const privacyForExample = (record) => isRecord(record.privacy)
+    ? record.privacy
+    : undefined;
+const labelsForExample = (record) => {
+    const quality = isRecord(record.quality) ? record.quality : undefined;
+    const labels = Array.isArray(quality?.labels) ? quality.labels : [];
+    return labels
+        .filter((label) => typeof label === "string" && label.trim().length > 0)
+        .map(normalizeToken);
+};
+const metadataForExample = (record) => isRecord(record.metadata) ? record.metadata : {};
+const refMetadataToken = (ref, keys) => readString(isRecord(ref.metadata) ? ref.metadata : undefined, keys);
+const explicitArtifactTypesForExample = (record, refs) => uniqueSorted([
+    readString(metadataForExample(record), [
+        "artifactType",
+        "artifact_type",
+        "exampleType",
+        "example_type",
+    ]),
+    ...refs.map((ref) => refMetadataToken(ref, ["artifactType", "artifact_type"])),
+]).map(normalizeToken);
+const artifactTypesForExportKind = (exportKind) => {
+    const normalized = normalizeToken(exportKind);
+    if (exportKind === "prompt-regression")
+        return [normalized, "prompt"];
+    if (exportKind === "eval-replay")
+        return [normalized, "eval_replay", "replay"];
+    if (exportKind.endsWith("-sft"))
+        return [normalized, "sft", "training"];
+    return [normalized];
+};
+const artifactTypesForExample = (record, refs, manifest) => uniqueSorted([
+    ...explicitArtifactTypesForExample(record, refs),
+    ...artifactTypesForExportKind(manifest.exportKind),
+    ...refs.flatMap((ref) => [
+        ref.kind,
+        ref.mediaType,
+        ref.mimeType,
+        refMetadataToken(ref, ["artifactType", "artifact_type", "part"]),
+    ]),
+]).map(normalizeToken);
+const artifactFilterTypesForExample = (record, refs, manifest) => {
+    const explicitTypes = explicitArtifactTypesForExample(record, refs);
+    return explicitTypes.length > 0
+        ? explicitTypes
+        : artifactTypesForExportKind(manifest.exportKind).map(normalizeToken);
+};
+const extractNestedHash = (metadata, directKeys, nestedKeys) => {
+    const direct = readString(metadata, directKeys);
+    if (direct)
+        return direct;
+    for (const key of nestedKeys) {
+        const nested = metadata[key];
+        if (!isRecord(nested))
+            continue;
+        const hash = readString(nested, ["hash", "contentHash", "content_hash"]);
+        if (hash)
+            return hash;
+    }
+    return undefined;
+};
+const lineageKeyForExample = (record, refs, manifest) => {
+    const metadata = metadataForExample(record);
+    const recordId = readString(record, ["recordId", "record_id"]) ?? "";
+    return {
+        runIds: uniqueSorted([
+            readString(metadata, ["runId", "run_id"]),
+            ...refs.map((ref) => ref.ownerScope?.runId),
+        ]),
+        deletionGroupIds: uniqueSorted([
+            ...(manifest.deletionGroupSnapshot.byRecordId[recordId] ?? []),
+            ...refs.map((ref) => ref.deletionGroupId),
+            readString(metadata, ["deletionGroupId", "deletion_group_id"]),
+        ]),
+        taskHash: extractNestedHash(metadata, ["taskHash", "task_hash"], ["task", "taskMetadata", "task_metadata"]),
+        promptHash: extractNestedHash(metadata, ["promptHash", "prompt_hash"], ["prompt", "promptMetadata", "prompt_metadata"]) ?? refs[0]?.contentHash,
+        toolContractHash: extractNestedHash(metadata, ["toolContractHash", "tool_contract_hash"], ["toolContract", "tool_contract", "toolMetadata", "tool_metadata"]),
+        expectedTargetHash: extractNestedHash(metadata, ["expectedTargetHash", "expected_target_hash", "targetHash", "target_hash"], ["expectedTarget", "expected_target", "target"]) ?? refs.find((ref) => ref !== refs[0])?.contentHash,
+    };
+};
+const dedupeKeyForLineage = (lineageKey, recordId) => {
+    const hasLineage = lineageKey.runIds.length > 0 ||
+        lineageKey.deletionGroupIds.length > 0 ||
+        Boolean(lineageKey.taskHash) ||
+        Boolean(lineageKey.promptHash) ||
+        Boolean(lineageKey.toolContractHash) ||
+        Boolean(lineageKey.expectedTargetHash);
+    return `lineage-${sha256Hex(JSON.stringify(hasLineage
+        ? lineageKey
+        : { recordId })).slice(0, 24)}`;
+};
+const hasLabel = (labels, tokens) => labels.some((label) => tokens.some((token) => label.includes(token)));
+const preferenceSignalsForExample = (record) => {
+    const quality = isRecord(record.quality) ? record.quality : {};
+    const metadata = metadataForExample(record);
+    const labels = labelsForExample(record);
+    const score = readNumber(quality, ["score"]);
+    const confidence = normalizeToken(readString(metadata, [
+        "confidence",
+        "confidenceBucket",
+        "confidence_bucket",
+    ]) ?? "");
+    const signals = [];
+    const humanReviewed = readBoolean(quality, ["reviewed"]) === true ||
+        Boolean(readString(metadata, ["reviewId", "review_id", "reviewerId", "reviewer_id"])) ||
+        hasLabel(labels, ["human_reviewed", "reviewed", "review_approved", "review_gold"]);
+    if (humanReviewed)
+        signals.push("human_reviewed");
+    const acceptedCorrection = readBoolean(metadata, ["acceptedCorrection", "accepted_correction"]) === true ||
+        hasLabel(labels, [
+            "accepted_correction",
+            "correction_accepted",
+            "review_accepted",
+            "review_approved",
+        ]) ||
+        ["accepted", "approved"].includes(normalizeToken(readString(metadata, [
+            "reviewDecision",
+            "review_decision",
+            "correctionDecision",
+            "correction_decision",
+        ]) ?? ""));
+    if (acceptedCorrection)
+        signals.push("accepted_correction");
+    if (confidence === "high" ||
+        hasLabel(labels, ["confidence_high", "high_confidence"]) ||
+        (score !== undefined && score >= 0.8)) {
+        signals.push("high_confidence");
+    }
+    const negativeStrength = readNumber(metadata, [
+        "negativeExampleStrength",
+        "negative_example_strength",
+    ]);
+    if (readBoolean(metadata, ["strongNegative", "strong_negative"]) === true ||
+        hasLabel(labels, ["strong_negative", "negative_strong", "hard_negative"]) ||
+        negativeStrength !== undefined && negativeStrength >= 0.8) {
+        signals.push("strong_negative");
+    }
+    return Array.from(new Set(signals));
+};
+const priorityScoreForExample = (record, signals) => {
+    const quality = isRecord(record.quality) ? record.quality : {};
+    const score = readNumber(quality, ["score"]) ?? 0;
+    return ((signals.includes("human_reviewed") ? 1000 : 0) +
+        (signals.includes("accepted_correction") ? 800 : 0) +
+        (signals.includes("high_confidence") ? 500 : 0) +
+        (signals.includes("strong_negative") ? 400 : 0) +
+        Math.round(score * 100));
+};
+const purposesForExportKind = (exportKind) => {
+    const purposes = ["export"];
+    if (exportKind === "eval-replay")
+        purposes.push("eval", "replay");
+    if (exportKind.endsWith("-sft"))
+        purposes.push("training");
+    return purposes;
+};
+const reasonFromBlocker = (code, message, blocker, details) => ({
+    code,
+    message,
+    ...(blocker.path ? { path: blocker.path } : {}),
+    details: {
+        ...details,
+        privacyCode: blocker.code,
+    },
+});
+export const evaluateDatasetExportArtifactPayloadRead = (manifest, primaryArtifactRef) => {
+    if (!manifest.privacy) {
+        return [{
+                code: "privacy_metadata_missing",
+                message: "Export manifest privacy metadata is required before artifact payload reads.",
+                path: "$.privacy",
+            }];
+    }
+    const decision = evaluateCodaliDatasetObjectPayloadRead("export", primaryArtifactRef, manifest.privacy);
+    if (decision.allowed)
+        return [];
+    return decision.blockers.map((blocker) => reasonFromBlocker("artifact_privacy_read_disallowed", blocker.message, blocker, {
+        purpose: "export",
+        refId: primaryArtifactRef.refId,
+    }));
+};
+const revokedDeletionGroupIds = (manifest, explicitIds) => {
+    const metadata = isRecord(manifest.metadata) ? manifest.metadata : {};
+    const snapshot = manifest.deletionGroupSnapshot;
+    const snapshotRecord = isRecord(snapshot) ? snapshot : {};
+    return uniqueSorted([
+        ...(explicitIds ?? []),
+        ...stringList(metadata.revokedDeletionGroupIds),
+        ...stringList(metadata.revoked_deletion_group_ids),
+        ...recordList(metadata.deletionGroupRevocations)
+            .map((entry) => readString(entry, ["deletionGroupId", "deletion_group_id"])),
+        ...stringList(snapshotRecord.revokedDeletionGroupIds),
+        ...stringList(snapshotRecord.revoked_deletion_group_ids),
+    ]);
+};
+const artifactTypeReasons = (artifactTypes, allowedArtifactTypes) => {
+    if (!allowedArtifactTypes || allowedArtifactTypes.length === 0)
+        return [];
+    const allowed = new Set(allowedArtifactTypes.map(normalizeToken));
+    if (artifactTypes.length === 0) {
+        return [{
+                code: "artifact_type_missing",
+                message: "Example artifact type is required by the curation filter.",
+                path: "$.metadata.artifactType",
+                details: {
+                    allowedArtifactTypes: [...allowed].sort(),
+                },
+            }];
+    }
+    if (artifactTypes.some((type) => allowed.has(type)))
+        return [];
+    return [{
+            code: "artifact_type_not_allowed",
+            message: "Example artifact type is not allowed by the curation filter.",
+            path: "$.metadata.artifactType",
+            details: {
+                artifactTypes,
+                allowedArtifactTypes: [...allowed].sort(),
+            },
+        }];
+};
+const parseExample = (row, index, input, revokedIds) => {
+    const record = isRecord(row) ? row : {};
+    const recordId = readString(record, ["recordId", "record_id"]) ?? `row-${index + 1}`;
+    const sourceGatewayRecordId = readString(record, [
+        "sourceGatewayRecordId",
+        "source_gateway_record_id",
+    ]);
+    const refs = refsForExample(record);
+    const privacy = privacyForExample(record);
+    const reasons = [];
+    if (!isRecord(row)) {
+        reasons.push({
+            code: "row_invalid",
+            message: "Curated example row must be an object.",
+            path: `$[${index}]`,
+        });
+    }
+    if (!readString(record, ["recordId", "record_id"])) {
+        reasons.push({
+            code: "row_invalid",
+            message: "Curated example row must include a record id.",
+            path: `$[${index}].recordId`,
+        });
+    }
+    if (refs.length === 0) {
+        reasons.push({
+            code: "row_invalid",
+            message: "Curated example row must include at least one object ref.",
+            path: `$[${index}].inputRef`,
+        });
+    }
+    if (!privacy) {
+        reasons.push({
+            code: "privacy_metadata_missing",
+            message: "Curated example privacy metadata is required before row object reads.",
+            path: `$[${index}].privacy`,
+        });
+    }
+    if (privacy) {
+        for (const purpose of purposesForExportKind(input.manifest.exportKind)) {
+            for (const ref of refs) {
+                const decision = evaluateCodaliDatasetObjectPayloadRead(purpose, ref, privacy);
+                if (!decision.allowed) {
+                    reasons.push(...decision.blockers.map((blocker) => reasonFromBlocker("row_privacy_read_disallowed", blocker.message, blocker, {
+                        purpose,
+                        refId: ref.refId,
+                        recordId,
+                    })));
+                }
+            }
+        }
+    }
+    const artifactTypes = artifactTypesForExample(record, refs, input.manifest);
+    const artifactFilterTypes = artifactFilterTypesForExample(record, refs, input.manifest);
+    reasons.push(...artifactTypeReasons(artifactFilterTypes, input.allowedArtifactTypes));
+    const lineageKey = lineageKeyForExample(record, refs, input.manifest);
+    const revokedForExample = lineageKey.deletionGroupIds.filter((id) => revokedIds.has(id));
+    if (revokedForExample.length > 0) {
+        reasons.push({
+            code: "deletion_group_revoked",
+            message: "Example lineage references a revoked deletion group.",
+            path: "$.deletionGroupSnapshot",
+            details: {
+                deletionGroupIds: revokedForExample,
+            },
+        });
+    }
+    const dedupeKey = dedupeKeyForLineage(lineageKey, recordId);
+    const preferenceSignals = preferenceSignalsForExample(record);
+    return {
+        record,
+        recordId,
+        ...(sourceGatewayRecordId ? { sourceGatewayRecordId } : {}),
+        refs,
+        privacy,
+        artifactTypes,
+        lineageKey,
+        dedupeKey,
+        preferenceSignals,
+        priorityScore: priorityScoreForExample(record, preferenceSignals),
+        reasons,
+    };
+};
+const rejectedExample = (parsed, reasons) => ({
+    targetType: "example",
+    recordId: parsed.recordId,
+    dedupeKey: parsed.dedupeKey,
+    reasons,
+});
+const reasonCounts = (rejected) => {
+    const counts = {};
+    for (const item of rejected) {
+        for (const reason of item.reasons) {
+            counts[reason.code] = (counts[reason.code] ?? 0) + 1;
+        }
+    }
+    return counts;
+};
+export class DatasetEligibilityGate {
+    curate(input) {
+        const exportId = input.exportId?.trim() || input.manifest.manifestId;
+        const artifactReadReasons = evaluateDatasetExportArtifactPayloadRead(input.manifest, input.primaryArtifactRef);
+        const warnings = [];
+        const rejected = [];
+        if (artifactReadReasons.length > 0) {
+            rejected.push({
+                targetType: "artifact",
+                recordId: input.primaryArtifactRef.refId,
+                reasons: artifactReadReasons,
+            });
+            warnings.push({
+                code: "artifact_payload_read_blocked",
+                message: "Primary export artifact payload was not read because privacy metadata disallowed it.",
+                details: {
+                    refId: input.primaryArtifactRef.refId,
+                },
+            });
+        }
+        const rows = artifactReadReasons.length === 0 ? input.rows ?? [] : [];
+        const revokedIds = new Set(revokedDeletionGroupIds(input.manifest, input.revokedDeletionGroupIds));
+        const parsedRows = rows.map((row, index) => parseExample(row, index, input, revokedIds));
+        const eligibleRows = [];
+        for (const parsed of parsedRows) {
+            if (parsed.reasons.length > 0) {
+                rejected.push(rejectedExample(parsed, parsed.reasons));
+            }
+            else {
+                eligibleRows.push(parsed);
+            }
+        }
+        const accepted = [];
+        const byDedupeKey = new Map();
+        for (const parsed of eligibleRows) {
+            const group = byDedupeKey.get(parsed.dedupeKey) ?? [];
+            group.push(parsed);
+            byDedupeKey.set(parsed.dedupeKey, group);
+        }
+        for (const [dedupeKey, group] of byDedupeKey.entries()) {
+            const sorted = [...group].sort((left, right) => right.priorityScore - left.priorityScore ||
+                left.recordId.localeCompare(right.recordId));
+            const winner = sorted[0];
+            if (!winner)
+                continue;
+            accepted.push({
+                recordId: winner.recordId,
+                ...(winner.sourceGatewayRecordId ? {
+                    sourceGatewayRecordId: winner.sourceGatewayRecordId,
+                } : {}),
+                dedupeKey,
+                lineageKey: winner.lineageKey,
+                deletionGroupIds: winner.lineageKey.deletionGroupIds,
+                runIds: winner.lineageKey.runIds,
+                artifactTypes: winner.artifactTypes,
+                preferenceSignals: winner.preferenceSignals,
+                priorityScore: winner.priorityScore,
+            });
+            for (const duplicate of sorted.slice(1)) {
+                rejected.push(rejectedExample(duplicate, [{
+                        code: "duplicate_lineage",
+                        message: "Example duplicates an already accepted lineage key.",
+                        details: {
+                            acceptedRecordId: winner.recordId,
+                            dedupeKey,
+                            lineageKey: duplicate.lineageKey,
+                        },
+                    }]));
+                warnings.push({
+                    code: "duplicate_lineage_dropped",
+                    message: "Duplicate lineage example was rejected during curation.",
+                    recordId: duplicate.recordId,
+                    dedupeKey,
+                    details: {
+                        acceptedRecordId: winner.recordId,
+                    },
+                });
+            }
+        }
+        accepted.sort((left, right) => right.priorityScore - left.priorityScore ||
+            left.recordId.localeCompare(right.recordId));
+        const lineageValid = !rejected.some((item) => item.reasons.some((reason) => reason.code === "deletion_group_revoked"));
+        if (!lineageValid) {
+            warnings.push({
+                code: "lineage_revoked",
+                message: "At least one curated example references a revoked deletion group.",
+            });
+        }
+        if (artifactReadReasons.length === 0 && rows.length > 0 && accepted.length === 0) {
+            warnings.push({
+                code: "no_accepted_examples",
+                message: "No examples passed the improvement eligibility gate.",
+            });
+        }
+        return {
+            schemaVersion: CODALI_IMPROVEMENT_ELIGIBILITY_GATE_SCHEMA_VERSION,
+            exportId,
+            manifestId: input.manifest.manifestId,
+            exportKind: input.manifest.exportKind,
+            artifactReadAllowed: artifactReadReasons.length === 0,
+            lineageValid,
+            totalExamples: rows.length,
+            acceptedCount: accepted.length,
+            rejectedCount: rejected.length,
+            warningCount: warnings.length,
+            acceptedRecordIds: accepted.map((item) => item.recordId),
+            rejectedRecordIds: rejected
+                .map((item) => item.recordId)
+                .filter((value) => Boolean(value)),
+            reasonCounts: reasonCounts(rejected),
+            accepted,
+            rejected,
+            warnings,
+        };
+    }
+}
+export const curateDatasetExportForImprovement = (input) => new DatasetEligibilityGate().curate(input);

package/dist/improvement/DatasetExportManifestReader.d.ts

@@ -0,0 +1,88 @@
+import { type CodaliStorageExportKind, type CodaliStorageExportManifest, type CodaliStorageObjectRef, type CodaliStorageValidationIssue } from "../storage/CodaliStorageContracts.js";
+import type { CodaliImprovementCandidateKind } from "./ImprovementPolicy.js";
+import { type DatasetEligibilityGateReport } from "./DatasetEligibilityGate.js";
+export declare const CODALI_IMPROVEMENT_MANIFEST_READER_SCHEMA_VERSION: "codali.improvement.manifest_reader.v1";
+export declare const CODALI_IMPROVEMENT_SUPPORTED_EXPORT_KINDS: readonly ["eval-replay", "model-router", "prompt-regression", "query-expander-sft", "rag-reranker"];
+export type DatasetExportManifestReaderWarningCode = "unsupported_export_kind";
+export interface DatasetExportManifestReaderWarning {
+    code: DatasetExportManifestReaderWarningCode;
+    message: string;
+    exportKind?: string;
+}
+export interface DatasetExportManifestReaderInput {
+    exportId?: string;
+    manifestPath?: string;
+    directory?: string;
+    supportedExportKinds?: readonly CodaliStorageExportKind[];
+    allowedExampleArtifactTypes?: readonly string[];
+    revokedDeletionGroupIds?: readonly string[];
+}
+export interface DatasetExportArtifactPayloadSummary {
+    payloadKind: "json" | "jsonl" | "text";
+    rowCount?: number;
+    byteSize: number;
+}
+export interface DatasetExportVerifiedArtifact {
+    ref: CodaliStorageObjectRef;
+    path: string;
+    contentHash: string;
+    byteSize: number;
+    payloadSummary: DatasetExportArtifactPayloadSummary;
+}
+export interface DatasetExportCandidateProvenance {
+    schemaVersion: typeof CODALI_IMPROVEMENT_MANIFEST_READER_SCHEMA_VERSION;
+    exportId: string;
+    manifestId: string;
+    manifestPath: string;
+    exportKind: CodaliStorageExportKind;
+    exportFormat: string;
+    checksum: string;
+    recordCount: number;
+    sourceRecordIds: string[];
+    sourceGatewayRecordIds: string[];
+    sourceObjectHashes: string[];
+    deletionGroupIds: string[];
+    artifactRefs: Array<{
+        refId: string;
+        contentHash: string;
+        byteSize: number;
+        mimeType: string;
+        uri?: string;
+    }>;
+    generatedBy?: string;
+    primaryArtifactRefId: string;
+    primaryArtifactContentHash: string;
+}
+export interface DatasetExportImprovementCandidate {
+    candidateId: string;
+    candidateKind: CodaliImprovementCandidateKind;
+    status: "proposed";
+    sourceExportIds: string[];
+    sourceRecordIds: string[];
+    artifactIds: string[];
+    exampleCount: number;
+    objectBytes: number;
+    provenance: DatasetExportCandidateProvenance;
+}
+export interface DatasetExportManifestReaderResult {
+    schemaVersion: typeof CODALI_IMPROVEMENT_MANIFEST_READER_SCHEMA_VERSION;
+    exportId: string;
+    manifestPath: string;
+    manifest: CodaliStorageExportManifest;
+    primaryArtifact?: DatasetExportVerifiedArtifact;
+    primaryArtifactRows: unknown[];
+    provenance: DatasetExportCandidateProvenance;
+    candidates: DatasetExportImprovementCandidate[];
+    warnings: DatasetExportManifestReaderWarning[];
+    curationReport: DatasetEligibilityGateReport;
+}
+export declare class DatasetExportManifestReaderError extends Error {
+    readonly code: string;
+    readonly issues?: CodaliStorageValidationIssue[];
+    constructor(code: string, message: string, issues?: CodaliStorageValidationIssue[]);
+}
+export declare class DatasetExportManifestReader {
+    inspect(input: DatasetExportManifestReaderInput): Promise<DatasetExportManifestReaderResult>;
+}
+export declare const inspectDatasetExportManifestForImprovement: (input: DatasetExportManifestReaderInput) => Promise<DatasetExportManifestReaderResult>;
+//# sourceMappingURL=DatasetExportManifestReader.d.ts.map

package/dist/improvement/DatasetExportManifestReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatasetExportManifestReader.d.ts","sourceRoot":"","sources":["../../src/improvement/DatasetExportManifestReader.ts"],"names":[],"mappings":"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"}