@snag-run/core 0.3.0

package/dist/schema.d.ts

@@ -0,0 +1,567 @@
+import { z } from "zod";
+declare const SCHEMA_ID: "failure-map/v1";
+/** FMEA risk factors (each 1-5). RPN = severity * frequency * detection. The
+ * default bounded encoding; see {@link generationSchemaNoNumericBounds} for the
+ * gateway-safe variant (#231). */
+export declare const scoresSchema: z.ZodObject<{
+    severity: z.ZodNumber;
+    frequency: z.ZodNumber;
+    detection: z.ZodNumber;
+}, z.core.$strip>;
+export type Scores = z.infer<typeof scoresSchema>;
+/** A non-failure node on the map (the happy-path spine + branches). */
+export declare const flowNodeSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        step: "step";
+        decision: "decision";
+        terminal: "terminal";
+        recovery: "recovery";
+    }>;
+    id: z.ZodString;
+    label: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FlowNode = z.infer<typeof flowNodeSchema>;
+/** A failure node / failure mode. Carries the required FMEA fields. */
+export declare const failureNodeSchema: z.ZodObject<{
+    scores: z.ZodObject<{
+        severity: z.ZodNumber;
+        frequency: z.ZodNumber;
+        detection: z.ZodNumber;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"failure">;
+    class: z.ZodString;
+    silent: z.ZodBoolean;
+    handled: z.ZodBoolean;
+    reviewWouldMiss: z.ZodBoolean;
+    trigger: z.ZodString;
+    manifestation: z.ZodString;
+    suggestedFix: z.ZodString;
+    fixEffort: z.ZodOptional<z.ZodEnum<{
+        trivial: "trivial";
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>>;
+    fingerprint: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    label: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FailureNode = z.infer<typeof failureNodeSchema>;
+/** Discriminated union on `type`: failure vs. flow node. */
+export declare const nodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    scores: z.ZodObject<{
+        severity: z.ZodNumber;
+        frequency: z.ZodNumber;
+        detection: z.ZodNumber;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"failure">;
+    class: z.ZodString;
+    silent: z.ZodBoolean;
+    handled: z.ZodBoolean;
+    reviewWouldMiss: z.ZodBoolean;
+    trigger: z.ZodString;
+    manifestation: z.ZodString;
+    suggestedFix: z.ZodString;
+    fixEffort: z.ZodOptional<z.ZodEnum<{
+        trivial: "trivial";
+        small: "small";
+        medium: "medium";
+        large: "large";
+    }>>;
+    fingerprint: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    label: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodEnum<{
+        step: "step";
+        decision: "decision";
+        terminal: "terminal";
+        recovery: "recovery";
+    }>;
+    id: z.ZodString;
+    label: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    sourceRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Node = z.infer<typeof nodeSchema>;
+export declare const edgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    type: z.ZodEnum<{
+        recovery: "recovery";
+        failure: "failure";
+        happy: "happy";
+        branch: "branch";
+    }>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Edge = z.infer<typeof edgeSchema>;
+/**
+ * The LLM generation surface: the tight { nodes, edges } analysis the model
+ * produces. Smallest surface = best structured-output reliability.
+ */
+export declare const generationSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scores: z.ZodObject<{
+            severity: z.ZodNumber;
+            frequency: z.ZodNumber;
+            detection: z.ZodNumber;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"failure">;
+        class: z.ZodString;
+        silent: z.ZodBoolean;
+        handled: z.ZodBoolean;
+        reviewWouldMiss: z.ZodBoolean;
+        trigger: z.ZodString;
+        manifestation: z.ZodString;
+        suggestedFix: z.ZodString;
+        fixEffort: z.ZodOptional<z.ZodEnum<{
+            trivial: "trivial";
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            step: "step";
+            decision: "decision";
+            terminal: "terminal";
+            recovery: "recovery";
+        }>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            recovery: "recovery";
+            failure: "failure";
+            happy: "happy";
+            branch: "branch";
+        }>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Generation = z.infer<typeof generationSchema>;
+export declare const generationSchemaNoNumericBounds: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scores: z.ZodObject<{
+            severity: z.ZodNumber;
+            frequency: z.ZodNumber;
+            detection: z.ZodNumber;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"failure">;
+        class: z.ZodString;
+        silent: z.ZodBoolean;
+        handled: z.ZodBoolean;
+        reviewWouldMiss: z.ZodBoolean;
+        trigger: z.ZodString;
+        manifestation: z.ZodString;
+        suggestedFix: z.ZodString;
+        fixEffort: z.ZodOptional<z.ZodEnum<{
+            trivial: "trivial";
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            step: "step";
+            decision: "decision";
+            terminal: "terminal";
+            recovery: "recovery";
+        }>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            recovery: "recovery";
+            failure: "failure";
+            happy: "happy";
+            branch: "branch";
+        }>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const REQUIRED_SOURCEREF_MESSAGE = "every code-map failure node must cite the file:line it lives on \u2014 set sourceRef (e.g. \"worktree.go:110\")";
+/** The bounded code-intake generation surface: {@link generationSchema} with a
+ * required `sourceRef` on failure nodes (#272). Sent to providers that accept
+ * integer numeric bounds (anthropic). */
+export declare const generationSchemaCode: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scores: z.ZodObject<{
+            severity: z.ZodNumber;
+            frequency: z.ZodNumber;
+            detection: z.ZodNumber;
+        }, z.core.$strip>;
+        sourceRef: z.ZodString;
+        type: z.ZodLiteral<"failure">;
+        class: z.ZodString;
+        silent: z.ZodBoolean;
+        handled: z.ZodBoolean;
+        reviewWouldMiss: z.ZodBoolean;
+        trigger: z.ZodString;
+        manifestation: z.ZodString;
+        suggestedFix: z.ZodString;
+        fixEffort: z.ZodOptional<z.ZodEnum<{
+            trivial: "trivial";
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            step: "step";
+            decision: "decision";
+            terminal: "terminal";
+            recovery: "recovery";
+        }>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            recovery: "recovery";
+            failure: "failure";
+            happy: "happy";
+            branch: "branch";
+        }>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The bounds-free code-intake generation surface: {@link
+ * generationSchemaNoNumericBounds} with a required `sourceRef` on failure nodes
+ * (#272). Sent to OpenAI-compatible gateways that reject integer bounds. */
+export declare const generationSchemaCodeNoNumericBounds: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scores: z.ZodObject<{
+            severity: z.ZodNumber;
+            frequency: z.ZodNumber;
+            detection: z.ZodNumber;
+        }, z.core.$strip>;
+        sourceRef: z.ZodString;
+        type: z.ZodLiteral<"failure">;
+        class: z.ZodString;
+        silent: z.ZodBoolean;
+        handled: z.ZodBoolean;
+        reviewWouldMiss: z.ZodBoolean;
+        trigger: z.ZodString;
+        manifestation: z.ZodString;
+        suggestedFix: z.ZodString;
+        fixEffort: z.ZodOptional<z.ZodEnum<{
+            trivial: "trivial";
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            step: "step";
+            decision: "decision";
+            terminal: "terminal";
+            recovery: "recovery";
+        }>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            recovery: "recovery";
+            failure: "failure";
+            happy: "happy";
+            branch: "branch";
+        }>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const flatGenerationSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            step: "step";
+            decision: "decision";
+            terminal: "terminal";
+            recovery: "recovery";
+            failure: "failure";
+        }>;
+        label: z.ZodString;
+        group: z.ZodNullable<z.ZodString>;
+        sourceRef: z.ZodNullable<z.ZodString>;
+        class: z.ZodNullable<z.ZodString>;
+        silent: z.ZodNullable<z.ZodBoolean>;
+        handled: z.ZodNullable<z.ZodBoolean>;
+        reviewWouldMiss: z.ZodNullable<z.ZodBoolean>;
+        trigger: z.ZodNullable<z.ZodString>;
+        manifestation: z.ZodNullable<z.ZodString>;
+        suggestedFix: z.ZodNullable<z.ZodString>;
+        fixEffort: z.ZodNullable<z.ZodEnum<{
+            trivial: "trivial";
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        scores: z.ZodNullable<z.ZodObject<{
+            severity: z.ZodNumber;
+            frequency: z.ZodNumber;
+            detection: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            recovery: "recovery";
+            failure: "failure";
+            happy: "happy";
+            branch: "branch";
+        }>;
+        condition: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FlatGeneration = z.infer<typeof flatGenerationSchema>;
+/**
+ * Project a flat strict-mode generation ({@link flatGenerationSchema}) back onto
+ * the canonical discriminated-union {@link Generation}: drop the `null`
+ * failure-only fields from flow nodes, keep them on failure nodes, strip `null`
+ * optionals, then re-validate through {@link generationSchema}. That final parse
+ * re-imposes everything the flat surface relaxed for strict's sake — the 1-5
+ * `scores` bounds, the per-`type` required fields (a `failure` node missing its
+ * `scores`/`class` throws here), unique ids and edge referential integrity — so a
+ * malformed flat map fails exactly as a malformed union map would. `input` is
+ * `unknown` (defence-in-depth for an injected seam): it is parsed through the flat
+ * schema first.
+ */
+export declare function normalizeFlatGeneration(input: unknown): Generation;
+/**
+ * Repair LLM-emitted node ids to the canonical {@link NODE_ID_PATTERN} (#280)
+ * and rewrite every edge endpoint with the SAME mapping so references stay
+ * intact (an un-rewritten endpoint would become a dangling edge). Ids are
+ * mechanical identifiers — a bad character should be slugified, never fatal.
+ *
+ * Identity-preserving by construction:
+ * - Distinct raw ids that slugify to the same value are kept distinct (a `_2`,
+ *   `_3`, … suffix on collision), so two nodes never silently merge.
+ * - Equal raw ids map to the same slug, so a genuine duplicate-id still trips
+ *   {@link refineNodesAndEdges} downstream (this does not paper over duplicates).
+ * - An empty slug (all-punctuation id) falls back to `node`.
+ * - An edge endpoint with no matching node id is left as-is, so a dangling edge
+ *   still surfaces as a referential-integrity error rather than being hidden.
+ *
+ * Does NOT touch the semantic `fingerprint` (over class/trigger/manifestation),
+ * so stable identity / reconciliation is unaffected.
+ */
+export declare function coerceNodeIds(generation: Generation): Generation;
+/** Split a code subject's `ref` ("a.go, dir/b.go") into its discovered path set
+ * (#272). Absent/empty ref → empty set (scope unknown: format is still checked,
+ * path membership is not). */
+export declare function scopePathsFromRef(ref: string | undefined): Set<string>;
+/**
+ * Validate a failure node's `sourceRef` as a concrete, in-scope citation (#272).
+ * Returns a human-readable problem (used verbatim as the retry/repair hint the
+ * model sees on a re-prompt) or `null` when the ref is acceptable. A valid ref is
+ * `file:line` (or `file:line-line`) whose `file` is one of the analyzed-scope
+ * paths. When `scopePaths` is empty the path-membership check is skipped (scope
+ * unknown) — the `file:line` shape is still enforced.
+ */
+export declare function sourceRefProblem(ref: string | null | undefined, scopePaths: ReadonlySet<string>): string | null;
+/**
+ * The artifact a Snag Map is derived from. `kind` is *what is being analyzed in
+ * the world* — `document` (a design) or `process` (a real business process; the
+ * intake is reserved, not wired yet), or a code grain: `function` ⊂ `module` ⊂
+ * `capability` (the cross-cutting grain spanning modules/boundaries, derived
+ * agentically by-name, #85), with `pull_request` the orthogonal change-axis. The
+ * enum is *additive* — already-committed maps keep validating as kinds are added.
+ */
+export declare const subjectSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        function: "function";
+        pull_request: "pull_request";
+        document: "document";
+        process: "process";
+        module: "module";
+        capability: "capability";
+    }>;
+    ref: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    sourceSha: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Subject = z.infer<typeof subjectSchema>;
+/** The code-intake subject kinds — the grains derived from existing source:
+ * `module` (review scope, {@link deriveCodeSubject}) and `capability` (by-name
+ * discovery, {@link deriveCapabilitySubject}). These are exactly the kinds for
+ * which a failure node MUST cite a `sourceRef` (#272); the spec kinds
+ * (`document`/`process`/`pull_request`) have no single source line to anchor.
+ * (`function` is in the enum but no intake derives it yet — it joins here when
+ * wired.) */
+export declare function isCodeIntakeKind(kind: Subject["kind"]): boolean;
+/** The harnesses that can drive the engine (#297) — pure provenance, nothing
+ * branches on the value. `snag` is the native CLI on API tokens; `claude-code`
+ * and `codex` are skills/wrappers that drive the same engine on a subscription.
+ * Knowing which produced a map is what makes the native-API-vs-via-harness
+ * quality comparison (eval / model-support work) possible. Additive: a new
+ * harness joins the enum without breaking already-committed maps. */
+export declare const HARNESSES: readonly ["snag", "claude-code", "codex"];
+export type Harness = (typeof HARNESSES)[number];
+/** Default harness when none is declared — the native `snag` CLI. */
+export declare const DEFAULT_HARNESS: Harness;
+/**
+ * Engine-stamped provenance (never produced by the LLM) — the poor-man's
+ * observability bridge to a future trace server.
+ */
+export declare const metaSchema: z.ZodObject<{
+    engineVersion: z.ZodString;
+    generatedAt: z.ZodString;
+    harness: z.ZodOptional<z.ZodEnum<{
+        snag: "snag";
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>>;
+    adapter: z.ZodString;
+    providerName: z.ZodOptional<z.ZodString>;
+    model: z.ZodString;
+    apiUrl: z.ZodOptional<z.ZodString>;
+    promptVersion: z.ZodString;
+    gatherStoppedAtCap: z.ZodOptional<z.ZodBoolean>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    tokenUsage: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Meta = z.infer<typeof metaSchema>;
+/** The full persisted failure-map/v1 document: envelope + analysis. */
+export declare const failureMapSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        scores: z.ZodObject<{
+            severity: z.ZodNumber;
+            frequency: z.ZodNumber;
+            detection: z.ZodNumber;
+        }, z.core.$strip>;
+        type: z.ZodLiteral<"failure">;
+        class: z.ZodString;
+        silent: z.ZodBoolean;
+        handled: z.ZodBoolean;
+        reviewWouldMiss: z.ZodBoolean;
+        trigger: z.ZodString;
+        manifestation: z.ZodString;
+        suggestedFix: z.ZodString;
+        fixEffort: z.ZodOptional<z.ZodEnum<{
+            trivial: "trivial";
+            small: "small";
+            medium: "medium";
+            large: "large";
+        }>>;
+        fingerprint: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodEnum<{
+            step: "step";
+            decision: "decision";
+            terminal: "terminal";
+            recovery: "recovery";
+        }>;
+        id: z.ZodString;
+        label: z.ZodString;
+        group: z.ZodOptional<z.ZodString>;
+        sourceRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        type: z.ZodEnum<{
+            recovery: "recovery";
+            failure: "failure";
+            happy: "happy";
+            branch: "branch";
+        }>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    schema: z.ZodLiteral<"failure-map/v1">;
+    subject: z.ZodObject<{
+        kind: z.ZodEnum<{
+            function: "function";
+            pull_request: "pull_request";
+            document: "document";
+            process: "process";
+            module: "module";
+            capability: "capability";
+        }>;
+        ref: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        sourceSha: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    meta: z.ZodObject<{
+        engineVersion: z.ZodString;
+        generatedAt: z.ZodString;
+        harness: z.ZodOptional<z.ZodEnum<{
+            snag: "snag";
+            "claude-code": "claude-code";
+            codex: "codex";
+        }>>;
+        adapter: z.ZodString;
+        providerName: z.ZodOptional<z.ZodString>;
+        model: z.ZodString;
+        apiUrl: z.ZodOptional<z.ZodString>;
+        promptVersion: z.ZodString;
+        gatherStoppedAtCap: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        tokenUsage: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            total: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type FailureMap = z.infer<typeof failureMapSchema>;
+export { SCHEMA_ID };
+/** Parse + validate the LLM generation surface; throws on invalid input. */
+export declare function parseGeneration(input: unknown): Generation;
+/** Parse + validate a full failure-map/v1 document; throws on invalid input. */
+export declare function parseFailureMap(input: unknown): FailureMap;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

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