@dailephd/my-dev-kit-lab 0.4.2 → 0.4.3

package/dist/src/evaluation/upstreamArtifacts/readJsonArtifact.js

@@ -0,0 +1,53 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+export async function readJsonArtifactFile(artifactKind, sourcePathInput) {
+    const sourcePath = path.resolve(sourcePathInput);
+    let raw;
+    try {
+        raw = await readFile(sourcePath, "utf8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return {
+                ok: false,
+                artifactKind,
+                sourcePath,
+                code: "FILE_NOT_FOUND",
+                message: `Artifact "${artifactKind}" file was not found at "${sourcePath}".`
+            };
+        }
+        return {
+            ok: false,
+            artifactKind,
+            sourcePath,
+            code: "UNREADABLE_FILE",
+            message: `Artifact "${artifactKind}" file at "${sourcePath}" could not be read: ${error.message}`
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            artifactKind,
+            sourcePath,
+            code: "MALFORMED_JSON",
+            message: `Artifact "${artifactKind}" file at "${sourcePath}" is not valid JSON: ${error.message}`
+        };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {
+            ok: false,
+            artifactKind,
+            sourcePath,
+            code: "NON_OBJECT_ROOT",
+            message: `Artifact "${artifactKind}" file at "${sourcePath}" must parse to a JSON object at the root.`,
+            expected: "object",
+            actual: parsed
+        };
+    }
+    return { ok: true, sourcePath, value: parsed };
+}

package/dist/src/evaluation/upstreamArtifacts/readMyDevKitContextCapsuleV1.js

@@ -0,0 +1,9 @@
+import { readJsonArtifactFile } from "./readJsonArtifact.js";
+import { validateMyDevKitContextCapsuleV1 } from "./validateMyDevKitContextCapsuleV1.js";
+const ARTIFACT_KIND = "my-dev-kit-context-capsule-v1";
+export async function readMyDevKitContextCapsuleV1(sourcePath) {
+    const loaded = await readJsonArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateMyDevKitContextCapsuleV1(loaded.value, loaded.sourcePath);
+}

package/dist/src/evaluation/upstreamArtifacts/readMyDevKitRetrievalAuditRecordV1.js

@@ -0,0 +1,9 @@
+import { readJsonArtifactFile } from "./readJsonArtifact.js";
+import { validateMyDevKitRetrievalAuditRecordV1 } from "./validateMyDevKitRetrievalAuditRecordV1.js";
+const ARTIFACT_KIND = "my-dev-kit-retrieval-audit-record-v1";
+export async function readMyDevKitRetrievalAuditRecordV1(sourcePath) {
+    const loaded = await readJsonArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateMyDevKitRetrievalAuditRecordV1(loaded.value, loaded.sourcePath);
+}

package/dist/src/evaluation/upstreamArtifacts/readOrchestratorWorkflowInstructionPacketV1.js

@@ -0,0 +1,9 @@
+import { readJsonArtifactFile } from "./readJsonArtifact.js";
+import { validateOrchestratorWorkflowInstructionPacketV1 } from "./validateOrchestratorWorkflowInstructionPacketV1.js";
+const ARTIFACT_KIND = "orchestrator-workflow-instruction-packet-v1";
+export async function readOrchestratorWorkflowInstructionPacketV1(sourcePath) {
+    const loaded = await readJsonArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateOrchestratorWorkflowInstructionPacketV1(loaded.value, loaded.sourcePath);
+}

package/dist/src/evaluation/upstreamArtifacts/runtimeValidation.js

@@ -0,0 +1,131 @@
+export function joinFieldPath(parent, child) {
+    return parent.length === 0 ? child : `${parent}.${child}`;
+}
+export function arrayFieldPath(parent, index) {
+    return `${parent}[${index}]`;
+}
+export function makeFailure(artifactKind, sourcePath, code, message, fieldPath, expected, actual) {
+    return { ok: false, artifactKind, sourcePath, code, message, fieldPath, expected, actual };
+}
+export class ArtifactValidationError extends Error {
+    failure;
+    constructor(failure) {
+        super(failure.message);
+        this.failure = failure;
+    }
+}
+function fail(artifactKind, sourcePath, code, message, fieldPath, expected, actual) {
+    throw new ArtifactValidationError(makeFailure(artifactKind, sourcePath, code, message, fieldPath, expected, actual));
+}
+export function requiredField(ctx, obj, key, fieldPath) {
+    if (!(key in obj)) {
+        fail(ctx.artifactKind, ctx.sourcePath, "MISSING_REQUIRED_FIELD", `Artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" is missing required field "${fieldPath}".`, fieldPath, "present");
+    }
+    return obj[key];
+}
+export function optionalField(obj, key) {
+    return key in obj ? obj[key] : undefined;
+}
+export function requiredObject(ctx, value, fieldPath) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be an object.`, fieldPath, "object", value);
+    }
+    return value;
+}
+export function requiredString(ctx, value, fieldPath) {
+    if (typeof value !== "string") {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be a string.`, fieldPath, "string", value);
+    }
+    return value;
+}
+export function optionalString(ctx, value, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    return requiredString(ctx, value, fieldPath);
+}
+export function requiredNullableString(ctx, value, fieldPath) {
+    if (value === null)
+        return null;
+    return requiredString(ctx, value, fieldPath);
+}
+export function optionalNullableString(ctx, value, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    return requiredNullableString(ctx, value, fieldPath);
+}
+export function requiredBoolean(ctx, value, fieldPath) {
+    if (typeof value !== "boolean") {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be a boolean.`, fieldPath, "boolean", value);
+    }
+    return value;
+}
+export function optionalBoolean(ctx, value, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    return requiredBoolean(ctx, value, fieldPath);
+}
+export function requiredNumber(ctx, value, fieldPath) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be a finite number.`, fieldPath, "number", value);
+    }
+    return value;
+}
+export function optionalNumber(ctx, value, fieldPath) {
+    if (value === undefined)
+        return undefined;
+    return requiredNumber(ctx, value, fieldPath);
+}
+export function requiredNullableNumber(ctx, value, fieldPath) {
+    if (value === null)
+        return null;
+    return requiredNumber(ctx, value, fieldPath);
+}
+export function requiredNonnegativeInteger(ctx, value, fieldPath) {
+    const n = requiredNumber(ctx, value, fieldPath);
+    if (!Number.isInteger(n) || n < 0) {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be a nonnegative integer.`, fieldPath, "nonnegative integer", value);
+    }
+    return n;
+}
+export function requiredLiteral(ctx, value, fieldPath, allowed) {
+    const str = requiredString(ctx, value, fieldPath);
+    if (!allowed.includes(str)) {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_LITERAL_VALUE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" has invalid value "${str}". Expected one of: ${allowed.join(", ")}.`, fieldPath, allowed.join(" | "), str);
+    }
+    return str;
+}
+export function optionalLiteral(ctx, value, fieldPath, allowed) {
+    if (value === undefined)
+        return undefined;
+    return requiredLiteral(ctx, value, fieldPath, allowed);
+}
+export function requiredNullableLiteral(ctx, value, fieldPath, allowed) {
+    if (value === null)
+        return null;
+    return requiredLiteral(ctx, value, fieldPath, allowed);
+}
+export function requiredArray(ctx, value, fieldPath) {
+    if (!Array.isArray(value)) {
+        fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be an array.`, fieldPath, "array", value);
+    }
+    return value;
+}
+export function requiredStringArray(ctx, value, fieldPath) {
+    const arr = requiredArray(ctx, value, fieldPath);
+    return arr.map((item, index) => requiredString(ctx, item, arrayFieldPath(fieldPath, index)));
+}
+export function requiredRecord(ctx, value, fieldPath) {
+    return requiredObject(ctx, value, fieldPath);
+}
+export function requiredScalarLike(ctx, value, fieldPath) {
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    fail(ctx.artifactKind, ctx.sourcePath, "INVALID_FIELD_TYPE", `Field "${fieldPath}" in artifact "${ctx.artifactKind}" at "${ctx.sourcePath}" must be a string, number, boolean, or null.`, fieldPath, "string | number | boolean | null", value);
+}
+export function requiredScalarOrStringArrayLike(ctx, value, fieldPath) {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => requiredString(ctx, item, arrayFieldPath(fieldPath, index)));
+    }
+    return requiredScalarLike(ctx, value, fieldPath);
+}

package/dist/src/evaluation/upstreamArtifacts/schemaVersion.js

@@ -0,0 +1,32 @@
+const SCHEMA_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+export function parseSupportedMajorOneSchemaVersion(value, artifactKind, sourcePath, fieldPath = "schemaVersion") {
+    if (typeof value !== "string" || !SCHEMA_VERSION_PATTERN.test(value)) {
+        return {
+            ok: false,
+            artifactKind,
+            sourcePath,
+            code: "INVALID_SCHEMA_VERSION",
+            message: `Artifact "${artifactKind}" at "${sourcePath}" has an invalid "${fieldPath}": expected strict "x.y.z" semantic version.`,
+            fieldPath,
+            expected: "^[0-9]+\\.[0-9]+\\.[0-9]+$",
+            actual: value
+        };
+    }
+    const [majorText, minorText, patchText] = value.split(".");
+    const major = Number(majorText);
+    const minor = Number(minorText);
+    const patch = Number(patchText);
+    if (major !== 1) {
+        return {
+            ok: false,
+            artifactKind,
+            sourcePath,
+            code: "UNSUPPORTED_SCHEMA_MAJOR",
+            message: `Artifact "${artifactKind}" at "${sourcePath}" has unsupported schema major "${major}" in "${fieldPath}": supported major is 1.`,
+            fieldPath,
+            expected: "1",
+            actual: value
+        };
+    }
+    return { version: value, major: 1, minor, patch };
+}