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

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 };
+}

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

@@ -0,0 +1,75 @@
+// Deterministic line-based parser for the frozen my-dev-kit-orchestrator supplemental
+// repository-context document format (commit bc08a05d3b52a629e7e4504372af199c324c4ae4,
+// src/instructions/supplementalContextParser.ts): "Key: value" metadata lines before the
+// first "## " heading, then "## Heading" sections running to the next heading or EOF.
+// Independently re-derived from the frozen contract for the lab's own read-only boundary;
+// never imports orchestrator runtime code. Structural classification only -- never
+// evaluates whether a declared value is true.
+const METADATA_LINE_RE = /^([A-Za-z][A-Za-z0-9 -]*): (.*)$/;
+const SECTION_HEADING_RE = /^## (.+)$/;
+export function parseSupplementalContextText(text) {
+    const lines = text.split(/\r\n|\n/);
+    const metadata = {};
+    const metadataOrder = [];
+    const duplicateMetadataKeys = [];
+    const emptyMetadataKeys = [];
+    let i = 0;
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        if (SECTION_HEADING_RE.test(line))
+            break;
+        const match = line.match(METADATA_LINE_RE);
+        if (!match)
+            continue;
+        const key = match[1];
+        const value = match[2].trim();
+        if (Object.prototype.hasOwnProperty.call(metadata, key)) {
+            duplicateMetadataKeys.push(key);
+            continue;
+        }
+        if (value.length === 0) {
+            emptyMetadataKeys.push(key);
+        }
+        metadata[key] = value;
+        metadataOrder.push(key);
+    }
+    const sections = {};
+    const sectionOrder = [];
+    const duplicateSectionHeadings = [];
+    let currentHeading = null;
+    let currentLines = [];
+    const flush = () => {
+        if (currentHeading === null)
+            return;
+        const content = currentLines.join("\n").trim();
+        if (Object.prototype.hasOwnProperty.call(sections, currentHeading)) {
+            duplicateSectionHeadings.push(currentHeading);
+        }
+        else {
+            sections[currentHeading] = content;
+            sectionOrder.push(currentHeading);
+        }
+    };
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        const headingMatch = line.match(SECTION_HEADING_RE);
+        if (headingMatch) {
+            flush();
+            currentHeading = headingMatch[1].trim();
+            currentLines = [];
+        }
+        else if (currentHeading !== null) {
+            currentLines.push(line);
+        }
+    }
+    flush();
+    return {
+        metadata,
+        metadataOrder,
+        sections,
+        sectionOrder,
+        duplicateMetadataKeys,
+        emptyMetadataKeys,
+        duplicateSectionHeadings
+    };
+}

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

@@ -0,0 +1,152 @@
+// Lab-owned structural mirror of the frozen my-dev-kit-orchestrator supplemental
+// repository-context document vocabulary (commit bc08a05d3b52a629e7e4504372af199c324c4ae4,
+// src/instructions/supplementalContextTypes.ts). The lab never imports orchestrator
+// runtime code; this file only restates the frozen vocabulary needed to validate and
+// preserve documents the orchestrator already writes.
+export const SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR = 1;
+export const SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR = 1;
+export const ROLE_BY_DOCUMENT_KIND = {
+    "implementation-context-packet": "implementation",
+    "implementation-context-retrieval-report": "implementation",
+    "test-context-packet": "test-implementation",
+    "test-context-retrieval-report": "test-implementation"
+};
+export function isRetrievalReportKind(kind) {
+    return kind === "implementation-context-retrieval-report" || kind === "test-context-retrieval-report";
+}
+export function isTestKind(kind) {
+    return kind === "test-context-packet" || kind === "test-context-retrieval-report";
+}
+const COMMON_PACKET_METADATA = [
+    "Schema version",
+    "Document kind",
+    "Role",
+    "Status",
+    "Repository scope",
+    "Freshness",
+    "Adequacy",
+    "Required evidence truncated",
+    "Context capsule schema version",
+    "Retrieval audit schema version",
+    "Tool name",
+    "Tool version",
+    "Index identity"
+];
+const COMMON_REPORT_METADATA = [
+    "Schema version",
+    "Document kind",
+    "Role",
+    "Status",
+    "Repository scope",
+    "Request schema version",
+    "Context capsule schema version",
+    "Retrieval audit schema version",
+    "Tool name",
+    "Tool version",
+    "Index identity",
+    "Freshness",
+    "Adequacy",
+    "Required evidence truncated",
+    "Full-file fallback used",
+    "Determinism checked"
+];
+const TEST_ONLY_METADATA = ["Responsibility mappings truncated", "Critical responsibility mapping status"];
+export const REQUIRED_METADATA_BY_DOCUMENT_KIND = {
+    "implementation-context-packet": COMMON_PACKET_METADATA,
+    "implementation-context-retrieval-report": COMMON_REPORT_METADATA,
+    "test-context-packet": [...COMMON_PACKET_METADATA, ...TEST_ONLY_METADATA],
+    "test-context-retrieval-report": [...COMMON_REPORT_METADATA, ...TEST_ONLY_METADATA]
+};
+export const REQUIRED_SECTIONS_BY_DOCUMENT_KIND = {
+    "implementation-context-packet": [
+        "Focus",
+        "Selected owners",
+        "Dependencies",
+        "Contracts",
+        "Validators",
+        "Constants",
+        "Errors",
+        "Schemas",
+        "Callers and callees",
+        "Closest tests",
+        "Test infrastructure",
+        "Test commands",
+        "Unresolved items",
+        "Budget and truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Assumptions",
+        "Notes"
+    ],
+    "implementation-context-retrieval-report": [
+        "Retrieval request",
+        "Command record",
+        "Focus selection",
+        "Candidate and owner selection",
+        "Evidence groups",
+        "Unresolved evidence",
+        "Adequacy evaluation",
+        "Freshness classification",
+        "Budget",
+        "Truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Warnings",
+        "Determinism",
+        "Assumptions",
+        "Notes"
+    ],
+    "test-context-packet": [
+        "Changed surface",
+        "Production owners",
+        "Production contracts",
+        "Validators",
+        "Constants",
+        "Errors",
+        "Schemas",
+        "Closest tests",
+        "Test infrastructure",
+        "Test commands",
+        "Test responsibilities",
+        "Responsibility mappings",
+        "Reusable test helpers",
+        "Oracle evidence",
+        "Unresolved items",
+        "Budget and truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Assumptions",
+        "Notes"
+    ],
+    "test-context-retrieval-report": [
+        "Retrieval request",
+        "Command record",
+        "Changed-surface selection",
+        "Production-owner selection",
+        "Test-infrastructure discovery",
+        "Test-command discovery",
+        "Responsibility mapping",
+        "Criticality overlay",
+        "Adequacy evaluation",
+        "Freshness classification",
+        "Budget",
+        "Truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Warnings",
+        "Determinism",
+        "Assumptions",
+        "Notes"
+    ]
+};
+export const VALID_REPOSITORY_SCOPES = ["single-repository", "source-target"];
+export const VALID_DECLARED_STATUSES = ["template", "populated"];
+export const VALID_FRESHNESS_VALUES = ["fresh", "stale", "unknown"];
+export const VALID_ADEQUACY_VALUES = [
+    "sufficient",
+    "sufficient-with-assumptions",
+    "insufficient",
+    "conflict",
+    "unknown"
+];
+export const VALID_TRUNCATION_VALUES = ["yes", "no", "unknown"];