@mergesignal/shared 0.2.8 → 0.3.0

package/dist/repoIntelligenceSchema.d.ts

@@ -1,106 +1,64 @@
+/**
+ * Canonical `ScanResult.repoIntelligence` wire contract (Wave 1 + Wave 2).
+ *
+ * Bump {@link REPO_INTELLIGENCE_ABI} when this schema changes incompatibly.
+ * Engine maps internal signals to this shape at emit time; consumers must use
+ * {@link safeParseRepoIntelligence} and honor `analysisPreparation.repoIntelligenceValidation`.
+ */
 import { z } from "zod";
-import type { BlastRadiusLevel, ReachabilityKind, RuntimeSurfaceKind } from "./scanNarrativeFacts.js";
-declare const looseSurfaceSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    unknown: "unknown";
-    runtime: "runtime";
-    build: "build";
-    test: "test";
-}>, z.ZodString, z.ZodObject<{
-    kind: z.ZodString;
-}, z.core.$loose>]>;
-declare const looseReachabilitySchema: z.ZodUnion<readonly [z.ZodEnum<{
-    unknown: "unknown";
-    on_runtime_paths: "on_runtime_paths";
-    build_only: "build_only";
-    test_only: "test_only";
-    unreachable: "unreachable";
-}>, z.ZodString, z.ZodObject<{
-    kind: z.ZodString;
-}, z.core.$loose>]>;
-export declare const repoIntelligenceSchema: z.ZodObject<{
-    packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        runtimeSurface: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+import type { ScanResult } from "./types.js";
+import type { BlastRadiusLevel } from "./scanNarrativeFacts.js";
+/** Bump when wire schema changes incompatibly. */
+export declare const REPO_INTELLIGENCE_ABI: "1";
+/** Strict canonical wire schema — single source of truth. */
+export declare const repoIntelligenceWireSchema: z.ZodObject<{
+    packages: z.ZodRecord<z.ZodString, z.ZodObject<{
+        runtimeSurface: z.ZodEnum<{
             unknown: "unknown";
             runtime: "runtime";
             build: "build";
             test: "test";
-        }>, z.ZodString, z.ZodObject<{
-            kind: z.ZodString;
-        }, z.core.$loose>]>>;
-        reachability: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        }>;
+        reachability: z.ZodEnum<{
             unknown: "unknown";
             on_runtime_paths: "on_runtime_paths";
             build_only: "build_only";
             test_only: "test_only";
             unreachable: "unreachable";
-        }>, z.ZodString, z.ZodObject<{
-            kind: z.ZodString;
-        }, z.core.$loose>]>>;
-        packageUsage: z.ZodOptional<z.ZodObject<{
-            packageName: z.ZodOptional<z.ZodString>;
-            package: z.ZodOptional<z.ZodString>;
-            files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }>;
+        usage: z.ZodObject<{
+            packageName: z.ZodString;
+            files: z.ZodArray<z.ZodString>;
             paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
             criticalPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
             areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$loose>>;
-        usage: z.ZodOptional<z.ZodObject<{
-            packageName: z.ZodOptional<z.ZodString>;
-            package: z.ZodOptional<z.ZodString>;
-            files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            criticalPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$loose>>;
+        }, z.core.$strip>;
         areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        hotspots: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            packageName: z.ZodOptional<z.ZodString>;
-            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            depth: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$loose>>>;
-    }, z.core.$loose>>>;
+    }, z.core.$strip>>;
     packageUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        packageName: z.ZodOptional<z.ZodString>;
-        package: z.ZodOptional<z.ZodString>;
-        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        packageName: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
         paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
         criticalPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
         areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$loose>>>;
+    }, z.core.$strip>>>;
     blastRadius: z.ZodOptional<z.ZodObject<{
-        level: z.ZodOptional<z.ZodEnum<{
+        level: z.ZodEnum<{
             moderate: "moderate";
             narrow: "narrow";
             wide: "wide";
-        }>>;
+        }>;
         factors: z.ZodOptional<z.ZodArray<z.ZodString>>;
         changedPackageCount: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$loose>>;
-    runtimeSurface: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        unknown: "unknown";
-        runtime: "runtime";
-        build: "build";
-        test: "test";
-    }>, z.ZodString, z.ZodObject<{
-        kind: z.ZodString;
-    }, z.core.$loose>]>>;
-    reachability: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        unknown: "unknown";
-        on_runtime_paths: "on_runtime_paths";
-        build_only: "build_only";
-        test_only: "test_only";
-        unreachable: "unreachable";
-    }>, z.ZodString, z.ZodObject<{
-        kind: z.ZodString;
-    }, z.core.$loose>]>>;
+    }, z.core.$strip>>;
     applicationAreas: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
-    }, z.core.$loose>>>;
+    }, z.core.$strip>>>;
     affectedAreas: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         label: z.ZodString;
-    }, z.core.$loose>>>;
+    }, z.core.$strip>>>;
     hotspots: z.ZodOptional<z.ZodArray<z.ZodObject<{
         packageName: z.ZodString;
         source: z.ZodOptional<z.ZodEnum<{
@@ -108,16 +66,27 @@ export declare const repoIntelligenceSchema: z.ZodObject<{
             graph: "graph";
         }>>;
         depth: z.ZodOptional<z.ZodNumber>;
-        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$loose>>>;
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
     frameworks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$loose>;
-export type RepoIntelligence = z.infer<typeof repoIntelligenceSchema>;
-export declare function parseRepoIntelligence(raw: unknown): RepoIntelligence | null;
-export declare function normalizeRuntimeSurfaceKind(raw: string | undefined): RuntimeSurfaceKind;
-export declare function normalizeReachabilityKind(raw: string | undefined): ReachabilityKind;
-export declare function readSurfaceFromLoose(value: z.infer<typeof looseSurfaceSchema> | undefined): RuntimeSurfaceKind | null;
-export declare function readReachabilityFromLoose(value: z.infer<typeof looseReachabilitySchema> | undefined): ReachabilityKind | null;
+}, z.core.$strip>;
+export type RepoIntelligence = z.infer<typeof repoIntelligenceWireSchema>;
+export type ParseRepoIntelligenceSuccess = {
+    ok: true;
+    value: RepoIntelligence;
+};
+export type ParseRepoIntelligenceFailure = {
+    ok: false;
+    issues: string[];
+    issueCount: number;
+    packageCount: number;
+};
+export type ParseRepoIntelligenceResult = ParseRepoIntelligenceSuccess | ParseRepoIntelligenceFailure;
+export declare function countRepoIntelligencePackages(raw: unknown): number;
+export declare function safeParseRepoIntelligence(raw: unknown): ParseRepoIntelligenceResult;
+/** Throws when wire block is present but invalid (CI / tests only). */
+export declare function validateRepoIntelligenceWire(raw: unknown): RepoIntelligence;
+/** CI helper — fails test when engine output includes invalid repoIntelligence. */
+export declare function assertEngineOutputRepoIntelligenceValid(scan: ScanResult): void;
 export declare function readBlastLevel(level: BlastRadiusLevel | undefined): BlastRadiusLevel | null;
-export {};
 //# sourceMappingURL=repoIntelligenceSchema.d.ts.map

package/dist/repoIntelligenceSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repoIntelligenceSchema.d.ts","sourceRoot":"","sources":["../src/repoIntelligenceSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,yBAAyB,CAAC;AAcjC,QAAA,MAAM,kBAAkB;;;;;;;mBAItB,CAAC;AAEH,QAAA,MAAM,uBAAuB;;;;;;;;mBAI3B,CAAC;AAyCH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BnB,CAAC;AAEjB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,IAAI,CAc3E;AAuBD,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,kBAAkB,CAUpB;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,gBAAgB,CAgBlB;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,GAAG,SAAS,GACpD,kBAAkB,GAAG,IAAI,CAO3B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,GAAG,SAAS,GACzD,gBAAgB,GAAG,IAAI,CAOzB;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,gBAAgB,GAAG,SAAS,GAClC,gBAAgB,GAAG,IAAI,CAKzB"}
+{"version":3,"file":"repoIntelligenceSchema.d.ts","sourceRoot":"","sources":["../src/repoIntelligenceSchema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,EAAG,GAAY,CAAC;AA+ClD,6DAA6D;AAC7D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQrC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE1E,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACnC,4BAA4B,GAC5B,4BAA4B,CAAC;AAQjC,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAUlE;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,GACX,2BAA2B,CAyC7B;AAED,uEAAuE;AACvE,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAM3E;AAED,mFAAmF;AACnF,wBAAgB,uCAAuC,CACrD,IAAI,EAAE,UAAU,GACf,IAAI,CAGN;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,gBAAgB,GAAG,SAAS,GAClC,gBAAgB,GAAG,IAAI,CAKzB"}

package/dist/repoIntelligenceSchema.js

@@ -1,4 +1,13 @@
+/**
+ * Canonical `ScanResult.repoIntelligence` wire contract (Wave 1 + Wave 2).
+ *
+ * Bump {@link REPO_INTELLIGENCE_ABI} when this schema changes incompatibly.
+ * Engine maps internal signals to this shape at emit time; consumers must use
+ * {@link safeParseRepoIntelligence} and honor `analysisPreparation.repoIntelligenceValidation`.
+ */
 import { z } from "zod";
+/** Bump when wire schema changes incompatibly. */
+export const REPO_INTELLIGENCE_ABI = "1";
 const surfaceKindSchema = z.enum(["runtime", "build", "test", "unknown"]);
 const reachabilityKindSchema = z.enum([
     "on_runtime_paths",
@@ -8,163 +17,112 @@ const reachabilityKindSchema = z.enum([
     "unknown",
 ]);
 const blastLevelSchema = z.enum(["narrow", "moderate", "wide"]);
-const looseSurfaceSchema = z.union([
-    surfaceKindSchema,
-    z.string(),
-    z.object({ kind: z.string() }).passthrough(),
-]);
-const looseReachabilitySchema = z.union([
-    reachabilityKindSchema,
-    z.string(),
-    z.object({ kind: z.string() }).passthrough(),
-]);
-const packageUsageEntrySchema = z
-    .object({
-    packageName: z.string().optional(),
-    package: z.string().optional(),
-    files: z.array(z.string()).optional(),
+const packageUsageWireSchema = z.object({
+    packageName: z.string().min(1),
+    files: z.array(z.string()),
     paths: z.array(z.string()).optional(),
     criticalPaths: z.array(z.string()).optional(),
     areas: z.array(z.string()).optional(),
-})
-    .passthrough();
-const packageIntelSchema = z
-    .object({
-    runtimeSurface: looseSurfaceSchema.optional(),
-    reachability: looseReachabilitySchema.optional(),
-    packageUsage: packageUsageEntrySchema.optional(),
-    usage: packageUsageEntrySchema.optional(),
+});
+const packageIntelWireSchema = z.object({
+    runtimeSurface: surfaceKindSchema,
+    reachability: reachabilityKindSchema,
+    usage: packageUsageWireSchema,
     areas: z.array(z.string()).optional(),
-    hotspots: z
-        .array(z
-        .object({
-        packageName: z.string().optional(),
-        paths: z.array(z.string()).optional(),
-        depth: z.number().optional(),
-    })
-        .passthrough())
-        .optional(),
-})
-    .passthrough();
-const areaSchema = z
-    .object({
-    id: z.string(),
-    label: z.string(),
-})
-    .passthrough();
-export const repoIntelligenceSchema = z
-    .object({
-    packages: z.record(z.string(), packageIntelSchema).optional(),
-    packageUsage: z.array(packageUsageEntrySchema).optional(),
-    blastRadius: z
-        .object({
-        level: blastLevelSchema.optional(),
-        factors: z.array(z.string()).optional(),
-        changedPackageCount: z.number().optional(),
-    })
-        .passthrough()
-        .optional(),
-    runtimeSurface: looseSurfaceSchema.optional(),
-    reachability: looseReachabilitySchema.optional(),
+});
+const areaSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1),
+});
+const hotspotWireSchema = z.object({
+    packageName: z.string().min(1),
+    source: z.enum(["code", "graph"]).optional(),
+    depth: z.number().optional(),
+    paths: z.array(z.string()),
+});
+const blastRadiusWireSchema = z.object({
+    level: blastLevelSchema,
+    factors: z.array(z.string()).optional(),
+    changedPackageCount: z.number().int().nonnegative().optional(),
+});
+/** Strict canonical wire schema — single source of truth. */
+export const repoIntelligenceWireSchema = z.object({
+    packages: z.record(z.string(), packageIntelWireSchema),
+    packageUsage: z.array(packageUsageWireSchema).optional(),
+    blastRadius: blastRadiusWireSchema.optional(),
     applicationAreas: z.array(areaSchema).optional(),
     affectedAreas: z.array(areaSchema).optional(),
-    hotspots: z
-        .array(z
-        .object({
-        packageName: z.string(),
-        source: z.enum(["code", "graph"]).optional(),
-        depth: z.number().optional(),
-        paths: z.array(z.string()).optional(),
-    })
-        .passthrough())
-        .optional(),
-    frameworks: z.array(z.string()).optional(),
-})
-    .passthrough();
-export function parseRepoIntelligence(raw) {
+    hotspots: z.array(hotspotWireSchema).optional(),
+    frameworks: z.array(z.string().min(1)).optional(),
+});
+function formatZodIssues(error) {
+    return error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`);
+}
+export function countRepoIntelligencePackages(raw) {
     if (raw == null || typeof raw !== "object")
-        return null;
-    const parsed = repoIntelligenceSchema.safeParse(raw);
-    if (!parsed.success)
-        return null;
-    const value = parsed.data;
-    if (Object.keys(value).length === 0)
-        return null;
-    if (Object.keys(value).length === 1 &&
-        value.packages &&
-        Object.keys(value.packages).length === 0) {
-        return null;
+        return 0;
+    const obj = raw;
+    if (obj.packages != null && typeof obj.packages === "object") {
+        return Object.keys(obj.packages).length;
+    }
+    if (Array.isArray(obj.packageUsage)) {
+        return obj.packageUsage.length;
     }
-    return value;
+    return 0;
 }
-const RUNTIME_SURFACE_ALIASES = [
-    [/\bruntime\b/i, "runtime"],
-    [/\bproduction\b/i, "runtime"],
-    [/\bapi\b/i, "runtime"],
-    [/\bbuild\b/i, "build"],
-    [/\bdev(?:elopment)?\b/i, "build"],
-    [/\btypescript\b/i, "build"],
-    [/\btest\b/i, "test"],
-    [/\bvitest\b/i, "test"],
-    [/\bjest\b/i, "test"],
-];
-const REACHABILITY_ALIASES = [
-    [/\bon[_\s-]?runtime/i, "on_runtime_paths"],
-    [/\bruntime[_\s-]?path/i, "on_runtime_paths"],
-    [/\bdirect\b/i, "on_runtime_paths"],
-    [/\bbuild[_\s-]?only/i, "build_only"],
-    [/\btest[_\s-]?only/i, "test_only"],
-    [/\bunreachable\b/i, "unreachable"],
-];
-export function normalizeRuntimeSurfaceKind(raw) {
-    if (!raw?.trim())
-        return "unknown";
-    const t = raw.trim().toLowerCase();
-    if (t === "runtime" || t === "build" || t === "test" || t === "unknown") {
-        return t;
+export function safeParseRepoIntelligence(raw) {
+    const packageCount = countRepoIntelligencePackages(raw);
+    if (raw == null || typeof raw !== "object") {
+        return {
+            ok: false,
+            issues: ["(root): expected object"],
+            issueCount: 1,
+            packageCount: 0,
+        };
     }
-    for (const [re, kind] of RUNTIME_SURFACE_ALIASES) {
-        if (re.test(t))
-            return kind;
+    const parsed = repoIntelligenceWireSchema.safeParse(raw);
+    if (!parsed.success) {
+        const issues = formatZodIssues(parsed.error);
+        return {
+            ok: false,
+            issues,
+            issueCount: issues.length,
+            packageCount,
+        };
     }
-    return "unknown";
-}
-export function normalizeReachabilityKind(raw) {
-    if (!raw?.trim())
-        return "unknown";
-    const t = raw.trim().toLowerCase();
-    if (t === "on_runtime_paths" ||
-        t === "build_only" ||
-        t === "test_only" ||
-        t === "unreachable" ||
-        t === "unknown") {
-        return t;
+    const value = parsed.data;
+    if (Object.keys(value).length === 0) {
+        return {
+            ok: false,
+            issues: ["(root): empty object"],
+            issueCount: 1,
+            packageCount: 0,
+        };
     }
-    for (const [re, kind] of REACHABILITY_ALIASES) {
-        if (re.test(t))
-            return kind;
+    if (Object.keys(value.packages).length === 0 &&
+        (value.packageUsage?.length ?? 0) === 0) {
+        return {
+            ok: false,
+            issues: ["packages: at least one package required"],
+            issueCount: 1,
+            packageCount: 0,
+        };
     }
-    return "unknown";
+    return { ok: true, value };
 }
-export function readSurfaceFromLoose(value) {
-    if (value == null)
-        return null;
-    if (typeof value === "string")
-        return normalizeRuntimeSurfaceKind(value);
-    if (typeof value === "object" && "kind" in value) {
-        return normalizeRuntimeSurfaceKind(String(value.kind));
+/** Throws when wire block is present but invalid (CI / tests only). */
+export function validateRepoIntelligenceWire(raw) {
+    const r = safeParseRepoIntelligence(raw);
+    if (!r.ok) {
+        throw new Error(`repoIntelligence contract: ${r.issues.join("; ")}`);
     }
-    return null;
+    return r.value;
 }
-export function readReachabilityFromLoose(value) {
-    if (value == null)
-        return null;
-    if (typeof value === "string")
-        return normalizeReachabilityKind(value);
-    if (typeof value === "object" && "kind" in value) {
-        return normalizeReachabilityKind(String(value.kind));
-    }
-    return null;
+/** CI helper — fails test when engine output includes invalid repoIntelligence. */
+export function assertEngineOutputRepoIntelligenceValid(scan) {
+    if (scan.repoIntelligence == null)
+        return;
+    validateRepoIntelligenceWire(scan.repoIntelligence);
 }
 export function readBlastLevel(level) {
     if (level === "narrow" || level === "moderate" || level === "wide") {

package/dist/repoIntelligenceValidation.d.ts

@@ -0,0 +1,18 @@
+import type { ScanResult } from "./types.js";
+export type RepoIntelligenceContractLogPayload = {
+    issueCount: number;
+    representativeIssues: string[];
+    packageCount: number;
+    methodologyVersion?: string;
+};
+/**
+ * Non-blocking production gate: validate repoIntelligence, attach metadata, retain raw payload.
+ */
+export declare function applyRepoIntelligenceValidation(result: ScanResult, options?: {
+    validatedAt?: string;
+}): {
+    result: ScanResult;
+    contractFailed: boolean;
+    logPayload?: RepoIntelligenceContractLogPayload;
+};
+//# sourceMappingURL=repoIntelligenceValidation.d.ts.map

package/dist/repoIntelligenceValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoIntelligenceValidation.d.ts","sourceRoot":"","sources":["../src/repoIntelligenceValidation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,UAAU,EACX,MAAM,YAAY,CAAC;AAOpB,MAAM,MAAM,kCAAkC,GAAG;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAIF;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,UAAU,EAClB,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACjC;IACD,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;IACxB,UAAU,CAAC,EAAE,kCAAkC,CAAC;CACjD,CAqFA"}

package/dist/repoIntelligenceValidation.js

@@ -0,0 +1,76 @@
+import { REPO_INTELLIGENCE_ABI, countRepoIntelligencePackages, safeParseRepoIntelligence, } from "./repoIntelligenceSchema.js";
+const MAX_REPRESENTATIVE_ISSUES = 5;
+/**
+ * Non-blocking production gate: validate repoIntelligence, attach metadata, retain raw payload.
+ */
+export function applyRepoIntelligenceValidation(result, options) {
+    const validatedAt = options?.validatedAt ?? new Date().toISOString();
+    const raw = result.repoIntelligence;
+    if (raw == null ||
+        (typeof raw === "object" && Object.keys(raw).length === 0)) {
+        const analysisPreparation = {
+            ...result.analysisPreparation,
+            codeIntelligenceAvailable: result.analysisPreparation?.codeIntelligenceAvailable ?? false,
+            warnings: result.analysisPreparation?.warnings ?? [],
+            repoIntelligenceValidation: {
+                status: "absent",
+                abi: REPO_INTELLIGENCE_ABI,
+                validatedAt,
+            },
+        };
+        return {
+            result: { ...result, analysisPreparation },
+            contractFailed: false,
+        };
+    }
+    const parsed = safeParseRepoIntelligence(raw);
+    const packageCount = countRepoIntelligencePackages(raw);
+    if (parsed.ok) {
+        const analysisPreparation = {
+            ...result.analysisPreparation,
+            codeIntelligenceAvailable: result.analysisPreparation?.codeIntelligenceAvailable ?? true,
+            warnings: result.analysisPreparation?.warnings ?? [],
+            repoIntelligenceValidation: {
+                status: "valid",
+                abi: REPO_INTELLIGENCE_ABI,
+                validatedAt,
+            },
+        };
+        return {
+            result: { ...result, analysisPreparation },
+            contractFailed: false,
+        };
+    }
+    const representativeIssues = parsed.issues.slice(0, MAX_REPRESENTATIVE_ISSUES);
+    const warning = {
+        code: "repo_intelligence_contract_invalid",
+        message: "Repository intelligence block failed contract validation; narrative uses graph fallback.",
+        details: {
+            issueCount: parsed.issueCount,
+            representativeIssues,
+            abi: REPO_INTELLIGENCE_ABI,
+        },
+    };
+    const analysisPreparation = {
+        ...result.analysisPreparation,
+        codeIntelligenceAvailable: result.analysisPreparation?.codeIntelligenceAvailable ?? true,
+        warnings: [...(result.analysisPreparation?.warnings ?? []), warning],
+        repoIntelligenceValidation: {
+            status: "invalid",
+            abi: REPO_INTELLIGENCE_ABI,
+            issueCount: parsed.issueCount,
+            representativeIssues,
+            validatedAt,
+        },
+    };
+    return {
+        result: { ...result, repoIntelligence: raw, analysisPreparation },
+        contractFailed: true,
+        logPayload: {
+            issueCount: parsed.issueCount,
+            representativeIssues,
+            packageCount,
+            methodologyVersion: result.methodologyVersion,
+        },
+    };
+}

package/dist/repoIntelligenceValidation.persist.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repoIntelligenceValidation.persist.test.d.ts.map

package/dist/repoIntelligenceValidation.persist.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repoIntelligenceValidation.persist.test.d.ts","sourceRoot":"","sources":["../src/repoIntelligenceValidation.persist.test.ts"],"names":[],"mappings":""}

package/dist/repoIntelligenceValidation.persist.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { deriveScanNarrative } from "./deriveScanNarrative.js";
+import { legacyEngineRepoIntelligenceJwt } from "./fixtures/legacyEngineRepoIntelligence.js";
+import { applyRepoIntelligenceValidation } from "./repoIntelligenceValidation.js";
+const baseScan = {
+    totalScore: 40,
+    layerScores: {
+        security: 10,
+        maintainability: 10,
+        ecosystem: 10,
+        upgradeImpact: 10,
+    },
+    findings: [],
+    generatedAt: "2026-01-01T00:00:00.000Z",
+    changedPackages: ["jsonwebtoken"],
+    analysisPreparation: {
+        codeIntelligenceAvailable: true,
+        warnings: [],
+    },
+};
+describe("applyRepoIntelligenceValidation (production persist model)", () => {
+    it("retains raw invalid repoIntelligence and marks status invalid", () => {
+        const { result, contractFailed, logPayload } = applyRepoIntelligenceValidation({
+            ...baseScan,
+            repoIntelligence: legacyEngineRepoIntelligenceJwt,
+        });
+        expect(contractFailed).toBe(true);
+        expect(logPayload?.issueCount).toBeGreaterThan(0);
+        expect(result.repoIntelligence).toEqual(legacyEngineRepoIntelligenceJwt);
+        expect(result.analysisPreparation?.repoIntelligenceValidation?.status).toBe("invalid");
+        expect(result.analysisPreparation?.warnings.some((w) => w.code === "repo_intelligence_contract_invalid")).toBe(true);
+    });
+    it("deriveScanNarrative ignores invalid wire (graph_fallback, untrusted parse status)", () => {
+        const { result } = applyRepoIntelligenceValidation({
+            ...baseScan,
+            repoIntelligence: legacyEngineRepoIntelligenceJwt,
+        });
+        const facts = deriveScanNarrative(result);
+        expect(facts.availability.repoIntelligenceParse).toBe("untrusted");
+        expect(facts.availability.tiersPresent.tier1).toBe(false);
+        expect(facts.availability.mode).not.toBe("pr_intelligence");
+        expect(facts.packageUsage).toHaveLength(0);
+    });
+});

package/dist/scanDetailViewModel.test.js

@@ -2,6 +2,7 @@ import { describe, expect, it } from "vitest";
 import { primaryPrExample } from "./productMessaging.js";
 import { ACT2_MAX_THEMES, TIER1_MAX_VISIBLE_IMPACTS, deriveAct2Themes, deriveOperationalImpact, deriveFollowUpBridgeNote, deriveScanDetailViewModel, deriveVerdictLine, sanitizeAct2Theme, tier1PassesRecallTest, } from "./scanDetailViewModel.js";
 import { fixtureRepoIntelligenceFastify } from "./fixtures/repoIntelligenceFixtures.js";
+import { analysisPreparationWithValidRepoIntel } from "./fixtures/repoIntelligenceTestHelpers.js";
 const baseResult = {
     totalScore: 10,
     layerScores: {
@@ -133,7 +134,7 @@ describe("Tier 1 success criterion", () => {
         const vm = deriveScanDetailViewModel({
             ...baseResult,
             changedPackages: ["fastify"],
-            analysisPreparation: { codeIntelligenceAvailable: true, warnings: [] },
+            analysisPreparation: analysisPreparationWithValidRepoIntel(),
             repoIntelligence: fixtureRepoIntelligenceFastify,
             insights: [
                 {

package/dist/scanNarrativeFacts.d.ts

@@ -14,6 +14,7 @@ export type NarrativePackageUsage = {
     files: string[];
     areas: string[];
 };
+export type RepoIntelligenceParseStatus = "ok" | "invalid" | "absent" | "untrusted";
 export type ScanNarrativeFacts = {
     availability: {
         mode: NarrativeAvailabilityMode;
@@ -23,6 +24,7 @@ export type ScanNarrativeFacts = {
             tier2: boolean;
             tier3: boolean;
         };
+        repoIntelligenceParse: RepoIntelligenceParseStatus;
     };
     changedPackages: {
         primary: string | null;