@mcoda/mswarm 0.1.89 → 0.1.91

package/dist/vendor/codali/improvement/DatasetExportManifestReader.js

@@ -0,0 +1,333 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { validateCodaliStorageExportManifest, } from "../storage/CodaliStorageContracts.js";
+import { curateDatasetExportForImprovement, } from "./DatasetEligibilityGate.js";
+export const CODALI_IMPROVEMENT_MANIFEST_READER_SCHEMA_VERSION = "codali.improvement.manifest_reader.v1";
+export const CODALI_IMPROVEMENT_SUPPORTED_EXPORT_KINDS = [
+    "eval-replay",
+    "model-router",
+    "prompt-regression",
+    "query-expander-sft",
+    "rag-reranker",
+];
+export class DatasetExportManifestReaderError extends Error {
+    constructor(code, message, issues) {
+        super(`${code}: ${message}`);
+        this.name = "DatasetExportManifestReaderError";
+        this.code = code;
+        this.issues = issues;
+    }
+}
+const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+const sha256Hex = (input) => createHash("sha256").update(input).digest("hex");
+const contentHash = (input) => `sha256:${sha256Hex(input)}`;
+const pathExists = async (value) => {
+    try {
+        await stat(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const normalizePath = (value) => value.startsWith("file://") ? fileURLToPath(value) : path.resolve(value);
+const defaultSearchDirectories = () => [
+    path.resolve(".codali", "dataset", "exports", "objects"),
+    path.resolve(".codali", "dataset", "exports"),
+    path.resolve(".codali", "dataset"),
+];
+const readJsonFile = async (filePath) => {
+    const raw = await readFile(filePath, "utf8");
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_MANIFEST_JSON_INVALID", error instanceof Error ? error.message : String(error));
+    }
+};
+const maybeManifestId = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    const manifestId = value.manifestId ?? value.manifest_id;
+    return typeof manifestId === "string" && manifestId.trim()
+        ? manifestId.trim()
+        : undefined;
+};
+const findManifestByExportId = async (directory, exportId) => {
+    const root = path.resolve(directory);
+    if (!(await pathExists(root)))
+        return undefined;
+    const stack = [root];
+    let inspected = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        const entries = (await readdir(current, { withFileTypes: true }))
+            .sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(entryPath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith(".json"))
+                continue;
+            inspected += 1;
+            if (inspected > 5000) {
+                throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_MANIFEST_SEARCH_LIMIT", `Manifest search inspected too many files under ${root}.`);
+            }
+            try {
+                const raw = await readFile(entryPath, "utf8");
+                const parsed = JSON.parse(raw);
+                if (maybeManifestId(parsed) === exportId)
+                    return entryPath;
+            }
+            catch {
+                // Object payload files can be JSONL or plain text. Ignore non-manifest files.
+            }
+        }
+    }
+    return undefined;
+};
+const resolveManifestPath = async (input) => {
+    if (input.manifestPath) {
+        const manifestPath = normalizePath(input.manifestPath);
+        if (!(await pathExists(manifestPath))) {
+            throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_MANIFEST_NOT_FOUND", `Manifest file not found: ${manifestPath}.`);
+        }
+        return manifestPath;
+    }
+    const exportId = input.exportId?.trim();
+    if (!exportId) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_ID_REQUIRED", "An export id or manifest path is required.");
+    }
+    const directPath = normalizePath(exportId);
+    if (await pathExists(directPath))
+        return directPath;
+    const directories = [
+        ...(input.directory ? [input.directory] : []),
+        ...defaultSearchDirectories(),
+    ];
+    for (const directory of directories) {
+        const directManifest = path.resolve(directory, `${exportId}.json`);
+        if (await pathExists(directManifest))
+            return directManifest;
+        const found = await findManifestByExportId(directory, exportId);
+        if (found)
+            return found;
+    }
+    throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_MANIFEST_NOT_FOUND", `No export manifest found for export id ${exportId}.`);
+};
+const validateManifest = async (manifestPath) => {
+    const parsed = await readJsonFile(manifestPath);
+    const validation = validateCodaliStorageExportManifest(parsed);
+    if (!validation.ok) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_MANIFEST_INVALID", validation.issues.map((issue) => `${issue.path}:${issue.code}`).join("; "), validation.issues);
+    }
+    return validation.value;
+};
+const objectRefPath = (ref) => {
+    if (!ref.uri?.startsWith("file://")) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_ARTIFACT_URI_UNSUPPORTED", `Artifact ${ref.refId} does not have a readable file:// URI.`);
+    }
+    return fileURLToPath(ref.uri);
+};
+const parseArtifactPayload = (ref, raw) => {
+    const text = raw.toString("utf8");
+    if (ref.mimeType === "application/x-ndjson" || ref.mediaType === "jsonl") {
+        const lines = text.trimEnd().length ? text.trimEnd().split(/\r?\n/) : [];
+        const rows = lines.map((line) => JSON.parse(line));
+        return {
+            summary: {
+                payloadKind: "jsonl",
+                rowCount: rows.length,
+                byteSize: raw.byteLength,
+            },
+            rows,
+        };
+    }
+    if (ref.mimeType === "application/json" || ref.mediaType === "json") {
+        const parsed = text.trim().length ? JSON.parse(text) : undefined;
+        const rows = isRecord(parsed) && Array.isArray(parsed.records)
+            ? parsed.records
+            : [];
+        return {
+            summary: {
+                payloadKind: "json",
+                rowCount: rows.length || undefined,
+                byteSize: raw.byteLength,
+            },
+            rows,
+        };
+    }
+    return {
+        summary: {
+            payloadKind: "text",
+            byteSize: raw.byteLength,
+        },
+        rows: [],
+    };
+};
+const verifyArtifact = async (ref, expectedHash) => {
+    const filePath = objectRefPath(ref);
+    const raw = await readFile(filePath);
+    const actualHash = contentHash(raw);
+    if (actualHash !== ref.contentHash || (expectedHash && actualHash !== expectedHash)) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_ARTIFACT_CHECKSUM_MISMATCH", `Artifact ${ref.refId} checksum mismatch.`);
+    }
+    if (ref.byteSize !== raw.byteLength) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_ARTIFACT_SIZE_MISMATCH", `Artifact ${ref.refId} byte size mismatch.`);
+    }
+    const parsed = parseArtifactPayload(ref, raw);
+    return {
+        artifact: {
+            ref,
+            path: filePath,
+            contentHash: actualHash,
+            byteSize: raw.byteLength,
+            payloadSummary: parsed.summary,
+        },
+        rows: parsed.rows,
+    };
+};
+const primaryArtifactRef = (manifest) => {
+    const matching = manifest.artifactRefs.find((ref) => ref.contentHash === manifest.checksum);
+    if (!matching) {
+        throw new DatasetExportManifestReaderError("CODALI_DATASET_EXPORT_ARTIFACT_MISSING", "Export manifest checksum does not point at a manifest artifact.");
+    }
+    return matching;
+};
+const uniqueStrings = (values) => Array.from(new Set(values.filter((value) => typeof value === "string" && value.trim().length > 0))).sort();
+const buildProvenance = (input) => ({
+    schemaVersion: CODALI_IMPROVEMENT_MANIFEST_READER_SCHEMA_VERSION,
+    exportId: input.exportId,
+    manifestId: input.manifest.manifestId,
+    manifestPath: input.manifestPath,
+    exportKind: input.manifest.exportKind,
+    exportFormat: input.manifest.exportFormat,
+    checksum: input.manifest.checksum,
+    recordCount: input.manifest.recordCount,
+    sourceRecordIds: uniqueStrings([
+        ...(input.acceptedRecordIds ?? input.manifest.lineage.sourceRecordIds),
+    ]),
+    sourceGatewayRecordIds: uniqueStrings([
+        ...(input.acceptedGatewayRecordIds ?? input.manifest.lineage.sourceGatewayRecordIds ?? []),
+    ]),
+    sourceObjectHashes: uniqueStrings(input.manifest.lineage.sourceObjectHashes),
+    deletionGroupIds: uniqueStrings([
+        ...(input.acceptedDeletionGroupIds ?? input.manifest.deletionGroupSnapshot.deletionGroupIds),
+    ]),
+    artifactRefs: input.manifest.artifactRefs.map((ref) => ({
+        refId: ref.refId,
+        contentHash: ref.contentHash,
+        byteSize: ref.byteSize,
+        mimeType: ref.mimeType,
+        ...(ref.uri ? { uri: ref.uri } : {}),
+    })),
+    ...(input.manifest.generatedBy ? { generatedBy: input.manifest.generatedBy } : {}),
+    primaryArtifactRefId: input.primaryArtifactRef.refId,
+    primaryArtifactContentHash: input.primaryArtifactContentHash,
+});
+const candidateKindForExport = (exportKind) => {
+    if (exportKind === "eval-replay")
+        return "eval_replay";
+    if (exportKind === "model-router")
+        return "model_router";
+    if (exportKind === "prompt-regression")
+        return "prompt";
+    return undefined;
+};
+const candidateIdForProvenance = (provenance) => `candidate-${sha256Hex(JSON.stringify({
+    exportId: provenance.exportId,
+    checksum: provenance.checksum,
+    sourceRecordIds: provenance.sourceRecordIds,
+})).slice(0, 16)}`;
+const buildCandidates = (provenance, curationReport) => {
+    const candidateKind = candidateKindForExport(provenance.exportKind);
+    if (!candidateKind ||
+        !curationReport.artifactReadAllowed ||
+        !curationReport.lineageValid ||
+        curationReport.acceptedCount === 0) {
+        return [];
+    }
+    return [{
+            candidateId: candidateIdForProvenance(provenance),
+            candidateKind,
+            status: "proposed",
+            sourceExportIds: [provenance.manifestId],
+            sourceRecordIds: provenance.sourceRecordIds,
+            artifactIds: provenance.artifactRefs.map((ref) => ref.refId),
+            exampleCount: curationReport.acceptedCount,
+            objectBytes: provenance.artifactRefs.reduce((total, ref) => total + ref.byteSize, 0),
+            provenance,
+        }];
+};
+const unsupportedWarnings = (manifest, supportedKinds) => supportedKinds.includes(manifest.exportKind)
+    ? []
+    : [{
+            code: "unsupported_export_kind",
+            exportKind: manifest.exportKind,
+            message: `Export kind ${manifest.exportKind} is not supported for improvement candidate generation.`,
+        }];
+export class DatasetExportManifestReader {
+    async inspect(input) {
+        const manifestPath = await resolveManifestPath(input);
+        const manifest = await validateManifest(manifestPath);
+        const primaryRef = primaryArtifactRef(manifest);
+        const exportId = input.exportId?.trim() || manifest.manifestId;
+        const preflightReport = curateDatasetExportForImprovement({
+            exportId,
+            manifest,
+            primaryArtifactRef: primaryRef,
+            allowedArtifactTypes: input.allowedExampleArtifactTypes,
+            revokedDeletionGroupIds: input.revokedDeletionGroupIds,
+        });
+        const verified = preflightReport.artifactReadAllowed
+            ? await verifyArtifact(primaryRef, manifest.checksum)
+            : undefined;
+        const curationReport = verified
+            ? curateDatasetExportForImprovement({
+                exportId,
+                manifest,
+                primaryArtifactRef: primaryRef,
+                rows: verified.rows,
+                allowedArtifactTypes: input.allowedExampleArtifactTypes,
+                revokedDeletionGroupIds: input.revokedDeletionGroupIds,
+            })
+            : preflightReport;
+        const provenance = buildProvenance({
+            exportId,
+            manifestPath,
+            manifest,
+            primaryArtifactRef: primaryRef,
+            primaryArtifactContentHash: verified?.artifact.contentHash ?? primaryRef.contentHash,
+            acceptedRecordIds: curationReport.acceptedRecordIds,
+            acceptedGatewayRecordIds: curationReport.accepted
+                .map((example) => example.sourceGatewayRecordId)
+                .filter((value) => Boolean(value)),
+            acceptedDeletionGroupIds: uniqueStrings(curationReport.accepted
+                .flatMap((example) => example.deletionGroupIds)),
+        });
+        const supportedKinds = input.supportedExportKinds ??
+            CODALI_IMPROVEMENT_SUPPORTED_EXPORT_KINDS;
+        const warnings = unsupportedWarnings(manifest, supportedKinds);
+        return {
+            schemaVersion: CODALI_IMPROVEMENT_MANIFEST_READER_SCHEMA_VERSION,
+            exportId,
+            manifestPath,
+            manifest,
+            ...(verified ? { primaryArtifact: verified.artifact } : {}),
+            primaryArtifactRows: verified?.rows ?? [],
+            provenance,
+            candidates: warnings.some((warning) => warning.code === "unsupported_export_kind")
+                ? []
+                : buildCandidates(provenance, curationReport),
+            warnings,
+            curationReport,
+        };
+    }
+}
+export const inspectDatasetExportManifestForImprovement = (input) => new DatasetExportManifestReader().inspect(input);

package/dist/vendor/codali/improvement/DocdexRetrievalCandidateBuilder.d.ts

@@ -0,0 +1,192 @@
+import type { CodaliStorageDatasetKind, CodaliStorageExportKind, CodaliStorageObjectPrivacyFlags } from "../storage/CodaliStorageContracts.js";
+import type { DatasetEligibilityGateAcceptedExample } from "./DatasetEligibilityGate.js";
+import type { DatasetExportManifestReaderResult } from "./DatasetExportManifestReader.js";
+export declare const CODALI_DOCDEX_RETRIEVAL_CANDIDATE_SCHEMA_VERSION: "codali.improvement.docdex_retrieval_candidate.v1";
+export declare const CODALI_DOCDEX_RETRIEVAL_PROPOSAL_ARTIFACT: "docdex-retrieval";
+export declare const CODALI_DOCDEX_RETRIEVAL_SOURCE_ARTIFACT_TYPES: readonly ["docdex_retrieval", "query_expander", "query_expander_sft", "rag_reranker", "rerank", "reranker", "retrieval", "freshness", "duplicate_detection", "source_selection"];
+export declare const CODALI_DOCDEX_RETRIEVAL_SUPPORTED_EXPORT_KINDS: readonly ["query-expander-sft", "rag-reranker"];
+export type CodaliDocdexRetrievalProposalArtifact = typeof CODALI_DOCDEX_RETRIEVAL_PROPOSAL_ARTIFACT;
+export type CodaliDocdexRetrievalCandidateKind = "docdex_retrieval";
+export type CodaliDocdexRetrievalRegressionKind = "freshness" | "duplicate_detection" | "source_selection";
+export interface CodaliDocdexRetrievalObjectRefSummary {
+    refId: string;
+    kind: string;
+    contentHash: string;
+    byteSize: number;
+    mimeType: string;
+    deletionGroupId: string;
+    privacyFlags: CodaliStorageObjectPrivacyFlags;
+    uri?: string;
+    mediaType?: string;
+    metadataKeys: string[];
+}
+export interface CodaliDocdexRetrievalPrivacyScope {
+    tenantScoped: boolean;
+    broadReuseAllowed: boolean;
+    rawTextAllowed: boolean;
+    reasons: string[];
+    policyTags: string[];
+}
+export interface CodaliDocdexRetrievalQueryVariant {
+    variantId: string;
+    queryHash: string;
+    text?: string;
+}
+export interface CodaliDocdexRetrievalQuerySummary {
+    queryHash: string;
+    text?: string;
+    storage: "inline_allowed" | "object_ref_or_hash_only";
+    variants: CodaliDocdexRetrievalQueryVariant[];
+}
+export interface CodaliDocdexRetrievalSourceSelection {
+    sourceHashes: string[];
+    sourceIds?: string[];
+    sourceTypes: string[];
+    selectedCount: number;
+}
+export interface CodaliDocdexRetrievalScorecard {
+    recall?: {
+        before?: number;
+        after?: number;
+        delta?: number;
+    };
+    precision?: {
+        before?: number;
+        after?: number;
+        delta?: number;
+    };
+    freshness?: {
+        before?: number;
+        after?: number;
+        delta?: number;
+    };
+}
+export interface CodaliDocdexRetrievalSourceExample {
+    recordId: string;
+    sourceGatewayRecordId?: string;
+    datasetKind?: CodaliStorageDatasetKind;
+    artifactTypes: string[];
+    preferenceSignals: string[];
+    priorityScore: number;
+    fineTuningPriority: "high" | "medium" | "low";
+    lineageKey: DatasetEligibilityGateAcceptedExample["lineageKey"];
+    privacyScope: CodaliDocdexRetrievalPrivacyScope;
+    query: CodaliDocdexRetrievalQuerySummary;
+    sourceSelection: CodaliDocdexRetrievalSourceSelection;
+    scorecard: CodaliDocdexRetrievalScorecard;
+    objectRefs: {
+        inputRef?: CodaliDocdexRetrievalObjectRefSummary;
+        outputRef?: CodaliDocdexRetrievalObjectRefSummary;
+        evidenceRefs: CodaliDocdexRetrievalObjectRefSummary[];
+    };
+    metadataShape: {
+        keys: string[];
+        retrievalKeys: string[];
+        scorecardKeys: string[];
+    };
+}
+export interface CodaliDocdexQueryExpanderEvalCandidate {
+    suiteId: string;
+    sourceExportId: string;
+    fineTuningPriority: {
+        strategy: "human_reviewed_then_accepted_correction_then_high_confidence";
+        orderedRecordIds: string[];
+    };
+    cases: Array<{
+        caseId: string;
+        sourceRecordId: string;
+        query: CodaliDocdexRetrievalQuerySummary;
+        expectedExpansionCount: number;
+        expectedRecallDeltaMin?: number;
+        privacyScope: CodaliDocdexRetrievalPrivacyScope;
+        objectRefs: CodaliDocdexRetrievalSourceExample["objectRefs"];
+    }>;
+}
+export interface CodaliDocdexRerankLabel {
+    labelId: string;
+    source: "accepted_evidence" | "rejected_evidence";
+    label: "positive" | "negative";
+    recordId?: string;
+    dedupeKey?: string;
+    queryHash?: string;
+    sourceHashes: string[];
+    reasonCodes: string[];
+    weight: number;
+}
+export interface CodaliDocdexRetrievalRegressionCase {
+    caseId: string;
+    kind: CodaliDocdexRetrievalRegressionKind;
+    sourceRecordIds: string[];
+    assertion: string;
+    queryHash?: string;
+    sourceHashes: string[];
+    reasonCodes: string[];
+}
+export interface CodaliDocdexEvalCommandSpec {
+    commandId: string;
+    command: "docdexd";
+    args: string[];
+    dryRunSafe: true;
+    requiresTenantScopedFixture: boolean;
+    expectedScorecards: Array<"recall" | "precision" | "freshness">;
+}
+export interface CodaliDocdexRetrievalImprovementCandidateSummary {
+    candidateId: string;
+    candidateKind: CodaliDocdexRetrievalCandidateKind;
+    status: "proposed" | "blocked";
+    sourceExportIds: string[];
+    sourceRecordIds: string[];
+    artifactIds: string[];
+    exampleCount: number;
+    objectBytes: number;
+    queryExpanderCaseCount: number;
+    rerankLabelCount: number;
+    regressionCaseCount: number;
+    blockedReasons: string[];
+}
+export interface CodaliDocdexRetrievalCandidateBundle {
+    schemaVersion: typeof CODALI_DOCDEX_RETRIEVAL_CANDIDATE_SCHEMA_VERSION;
+    artifact: CodaliDocdexRetrievalProposalArtifact;
+    source: {
+        exportId: string;
+        manifestId: string;
+        manifestPath: string;
+        exportKind: CodaliStorageExportKind;
+        checksum: string;
+        recordCount: number;
+        primaryArtifactRef: CodaliDocdexRetrievalObjectRefSummary;
+    };
+    generationPolicy: {
+        deterministic: true;
+        modifiesRuntimePrompts: false;
+        modifiesRuntimeCode: false;
+        bodyPolicy: "object_refs_and_hashes_only_for_private_sources";
+        tenantPrivateExamplesScoped: true;
+        uploadEnabled: false;
+        finalSynthesizerFineTuning: false;
+    };
+    expectedShape: {
+        schemaVersion: typeof CODALI_DOCDEX_RETRIEVAL_CANDIDATE_SCHEMA_VERSION;
+        artifact: CodaliDocdexRetrievalProposalArtifact;
+        requiredFields: string[];
+        sourceExampleRequiredFields: string[];
+        evalCommandRequiredFields: string[];
+    };
+    sourceExamples: CodaliDocdexRetrievalSourceExample[];
+    queryExpanderEval: CodaliDocdexQueryExpanderEvalCandidate;
+    rerankLabels: CodaliDocdexRerankLabel[];
+    regressionCases: CodaliDocdexRetrievalRegressionCase[];
+    docdexEvalCommands: CodaliDocdexEvalCommandSpec[];
+    scorecardSummary: {
+        recallDelta: number;
+        precisionDelta: number;
+        freshnessDelta: number;
+    };
+    candidates: CodaliDocdexRetrievalImprovementCandidateSummary[];
+}
+export interface BuildCodaliDocdexRetrievalCandidateBundleInput {
+    inspection: DatasetExportManifestReaderResult;
+    artifact?: CodaliDocdexRetrievalProposalArtifact;
+}
+export declare const buildCodaliDocdexRetrievalCandidateBundle: ({ inspection, artifact, }: BuildCodaliDocdexRetrievalCandidateBundleInput) => CodaliDocdexRetrievalCandidateBundle;
+//# sourceMappingURL=DocdexRetrievalCandidateBuilder.d.ts.map

package/dist/vendor/codali/improvement/DocdexRetrievalCandidateBuilder.d.ts.map

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