@pome-sh/cli 0.1.1 → 0.2.0

package/node_modules/@pome-sh/sdk/node_modules/@pome-sh/shared-types/dist/otel/event-schema.d.ts

@@ -0,0 +1,286 @@
+/**
+ * otel/event-schema — the OTel-inclusive event union (M1.1 / FDRS-480).
+ *
+ * `eventSchema` in `recorder-events.ts` is the FROZEN v1 legacy union (the
+ * recording-spec contract under the repo's change-lock policy). Rather than
+ * mutate that frozen union, this file composes the OTel-extended union
+ * ADDITIVELY — a non-breaking superset:
+ *
+ *   - `eventSchema`     (recorder-events.ts) — the v1 legacy-only union.
+ *   - `otelEventSchema` (this file)          — legacy variants PLUS `OtelSpanEvent`.
+ *
+ * OTel-aware consumers (M3 correlation, the native trace renderer) import
+ * `otelEventSchema`; readers that only handle the v1 legacy shapes keep using
+ * `eventSchema` and recognize `OtelSpanEvent` separately.
+ *
+ * This union is FORMAT surface and canonical HERE (ownership boundary settled
+ * at FDRS-653 — see `./index.ts`). pome-cloud consumes it; its earlier
+ * cloud-local composition of the same union collapses into this one at the
+ * FDRS-654 consumer swap.
+ */
+import { z } from "zod";
+export declare const otelEventSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ts: z.ZodString;
+    run_id: z.ZodString;
+    twin: z.ZodString;
+    request_id: z.ZodString;
+    correlation_id: z.ZodOptional<z.ZodString>;
+    task_step_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scenario_step_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    step_id: z.ZodNullable<z.ZodString>;
+    tool_call_id: z.ZodNullable<z.ZodString>;
+    method: z.ZodString;
+    path: z.ZodString;
+    request_body: z.ZodUnknown;
+    status: z.ZodNumber;
+    response_body: z.ZodUnknown;
+    latency_ms: z.ZodNumber;
+    fidelity: z.ZodEnum<{
+        semantic: "semantic";
+        unsupported: "unsupported";
+    }>;
+    state_mutation: z.ZodBoolean;
+    state_delta: z.ZodNullable<z.ZodObject<{
+        before: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        after: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    idempotency_dedupe: z.ZodOptional<z.ZodBoolean>;
+    error: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"TwinHttpEvent">;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"LlmCallEvent">;
+    host: z.ZodString;
+    port: z.ZodNumber;
+    latency_ms: z.ZodNumber;
+    bytes_in: z.ZodNumber;
+    bytes_out: z.ZodNumber;
+    url: z.ZodNullable<z.ZodString>;
+    method: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodNumber>;
+    model: z.ZodNullable<z.ZodString>;
+    prompt_tokens: z.ZodNullable<z.ZodNumber>;
+    completion_tokens: z.ZodNullable<z.ZodNumber>;
+    cost_usd: z.ZodNullable<z.ZodNumber>;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ToolUseEvent">;
+    tool_use_id: z.ZodString;
+    tool_name: z.ZodString;
+    input: z.ZodUnknown;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"ToolResultEvent">;
+    tool_use_id: z.ZodString;
+    output: z.ZodUnknown;
+    is_error: z.ZodBoolean;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"SubagentSpawnEvent">;
+    parent_tool_use_id: z.ZodString;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"HookEvent">;
+    hook_name: z.ZodString;
+    tool_name: z.ZodNullable<z.ZodString>;
+    ts: z.ZodString;
+    event_id: z.ZodString;
+    parent_id: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>], "kind">, z.ZodTransform<{
+    ts: string;
+    run_id: string;
+    twin: string;
+    request_id: string;
+    step_id: string | null;
+    tool_call_id: string | null;
+    method: string;
+    path: string;
+    request_body: unknown;
+    status: number;
+    response_body: unknown;
+    latency_ms: number;
+    fidelity: "semantic" | "unsupported";
+    state_mutation: boolean;
+    state_delta: {
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    } | null;
+    error: string | null;
+    kind: "TwinHttpEvent";
+    event_id: string;
+    parent_id: string | null;
+    correlation_id?: string | undefined;
+    task_step_id?: string | null | undefined;
+    scenario_step_id?: string | null | undefined;
+    idempotency_dedupe?: boolean | undefined;
+} | {
+    kind: "LlmCallEvent";
+    host: string;
+    port: number;
+    latency_ms: number;
+    bytes_in: number;
+    bytes_out: number;
+    url: string | null;
+    method: string | null;
+    status: number | null;
+    model: string | null;
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    cost_usd: number | null;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "ToolUseEvent";
+    tool_use_id: string;
+    tool_name: string;
+    input: unknown;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "ToolResultEvent";
+    tool_use_id: string;
+    output: unknown;
+    is_error: boolean;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "SubagentSpawnEvent";
+    parent_tool_use_id: string;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "HookEvent";
+    hook_name: string;
+    tool_name: string | null;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+}, {
+    ts: string;
+    run_id: string;
+    twin: string;
+    request_id: string;
+    step_id: string | null;
+    tool_call_id: string | null;
+    method: string;
+    path: string;
+    request_body: unknown;
+    status: number;
+    response_body: unknown;
+    latency_ms: number;
+    fidelity: "semantic" | "unsupported";
+    state_mutation: boolean;
+    state_delta: {
+        before: Record<string, unknown> | null;
+        after: Record<string, unknown> | null;
+    } | null;
+    error: string | null;
+    kind: "TwinHttpEvent";
+    event_id: string;
+    parent_id: string | null;
+    correlation_id?: string | undefined;
+    task_step_id?: string | null | undefined;
+    scenario_step_id?: string | null | undefined;
+    idempotency_dedupe?: boolean | undefined;
+} | {
+    kind: "LlmCallEvent";
+    host: string;
+    port: number;
+    latency_ms: number;
+    bytes_in: number;
+    bytes_out: number;
+    url: string | null;
+    method: string | null;
+    status: number | null;
+    model: string | null;
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    cost_usd: number | null;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "ToolUseEvent";
+    tool_use_id: string;
+    tool_name: string;
+    input: unknown;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "ToolResultEvent";
+    tool_use_id: string;
+    output: unknown;
+    is_error: boolean;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "SubagentSpawnEvent";
+    parent_tool_use_id: string;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+} | {
+    kind: "HookEvent";
+    hook_name: string;
+    tool_name: string | null;
+    ts: string;
+    event_id: string;
+    parent_id: string | null;
+}>>, z.ZodObject<{
+    ts: z.ZodString;
+    event_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    parent_id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    kind: z.ZodLiteral<"OtelSpanEvent">;
+    trace_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    span_id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    parent_span_id: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    name: z.ZodString;
+    span_kind: z.ZodEnum<{
+        UNSPECIFIED: "UNSPECIFIED";
+        INTERNAL: "INTERNAL";
+        SERVER: "SERVER";
+        CLIENT: "CLIENT";
+        PRODUCER: "PRODUCER";
+        CONSUMER: "CONSUMER";
+    }>;
+    start_time_unix_nano: z.ZodString;
+    end_time_unix_nano: z.ZodNullable<z.ZodString>;
+    status_code: z.ZodEnum<{
+        UNSET: "UNSET";
+        OK: "OK";
+        ERROR: "ERROR";
+    }>;
+    status_message: z.ZodNullable<z.ZodString>;
+    gen_ai_provider_name: z.ZodNullable<z.ZodString>;
+    gen_ai_operation_name: z.ZodNullable<z.ZodString>;
+    gen_ai_request_model: z.ZodNullable<z.ZodString>;
+    gen_ai_agent_name: z.ZodNullable<z.ZodString>;
+    gen_ai_agent_id: z.ZodNullable<z.ZodString>;
+    gen_ai_tool_name: z.ZodNullable<z.ZodString>;
+    gen_ai_usage_input_tokens: z.ZodNullable<z.ZodNumber>;
+    gen_ai_usage_output_tokens: z.ZodNullable<z.ZodNumber>;
+    http_request_method: z.ZodNullable<z.ZodString>;
+    http_response_status_code: z.ZodNullable<z.ZodNumber>;
+    url_full: z.ZodNullable<z.ZodString>;
+    url_path: z.ZodNullable<z.ZodString>;
+    server_address: z.ZodNullable<z.ZodString>;
+    server_port: z.ZodNullable<z.ZodNumber>;
+    error_type: z.ZodNullable<z.ZodString>;
+    attributes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>;
+}, z.core.$strip>]>;
+export type OtelEvent = z.infer<typeof otelEventSchema>;

package/node_modules/@pome-sh/sdk/node_modules/@pome-sh/shared-types/dist/otel/event-schema.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * otel/event-schema — the OTel-inclusive event union (M1.1 / FDRS-480).
+ *
+ * `eventSchema` in `recorder-events.ts` is the FROZEN v1 legacy union (the
+ * recording-spec contract under the repo's change-lock policy). Rather than
+ * mutate that frozen union, this file composes the OTel-extended union
+ * ADDITIVELY — a non-breaking superset:
+ *
+ *   - `eventSchema`     (recorder-events.ts) — the v1 legacy-only union.
+ *   - `otelEventSchema` (this file)          — legacy variants PLUS `OtelSpanEvent`.
+ *
+ * OTel-aware consumers (M3 correlation, the native trace renderer) import
+ * `otelEventSchema`; readers that only handle the v1 legacy shapes keep using
+ * `eventSchema` and recognize `OtelSpanEvent` separately.
+ *
+ * This union is FORMAT surface and canonical HERE (ownership boundary settled
+ * at FDRS-653 — see `./index.ts`). pome-cloud consumes it; its earlier
+ * cloud-local composition of the same union collapses into this one at the
+ * FDRS-654 consumer swap.
+ */
+import { z } from "zod";
+import { eventSchema } from "../recorder-events.js";
+import { otelSpanEventSchema } from "./span-event.js";
+// The OTel-inclusive event row: the legacy `eventSchema` (a discriminated union
+// over `kind`, with the FDRS-653 task-vocab normalization applied) OR an
+// `OtelSpanEvent`. A plain `z.union` is used rather than extending the
+// discriminated union because `otelSpanEventSchema` carries cross-field
+// `superRefine` invariants (it is not a bare `ZodObject`, so it cannot be a
+// discriminated-union member). For a 2-arm union this is a non-breaking
+// superset: legacy rows match the first arm, OtelSpanEvent rows the second.
+export const otelEventSchema = z.union([eventSchema, otelSpanEventSchema]);
+//# sourceMappingURL=event-schema.js.map

package/node_modules/@pome-sh/sdk/node_modules/@pome-sh/shared-types/dist/otel/event-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-schema.js","sourceRoot":"","sources":["../../src/otel/event-schema.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtD,gFAAgF;AAChF,yEAAyE;AACzE,uEAAuE;AACvE,wEAAwE;AACxE,4EAA4E;AAC5E,wEAAwE;AACxE,4EAA4E;AAC5E,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,mBAAmB,CAAC,CAAC,CAAC"}

package/node_modules/@pome-sh/sdk/node_modules/@pome-sh/shared-types/dist/otel/fixtures/data.d.ts

@@ -0,0 +1,65 @@
+/**
+ * otel/fixtures/data — frozen golden-fixture corpus (M1.3 / FDRS-482).
+ *
+ * The single source of truth for trace fixtures across M1.2 and M2–M6. Static
+ * data, deterministic by construction, and DEEP-FROZEN on export (review
+ * finding #6 — exported fixtures were runtime-mutable shared state). Four
+ * families:
+ *
+ *   - LEGACY_FIXTURES      — (legacy record → expected OtelSpanEvent) pairs.
+ *                            `expected` is the FROZEN output of the M1.2 shim;
+ *                            M1.2's golden test asserts the shim reproduces it.
+ *   - EMITTER_FIXTURES     — real-emitter spans (Traceloop / Vercel AI SDK /
+ *                            Pydantic Logfire), normalized to `OtelSpanInput`
+ *                            with provenance + version metadata. M1.1 parses them.
+ *   - TRACE_FIXTURES       — multi-span sub-agent traces (parent_span_id trees).
+ *   - EXTERNAL_API_FIXTURES — twin-relevant external-API (HTTP) spans (M4 drift).
+ *
+ * PROVENANCE NOTE (honest sourcing — `derivedFrom: "documentation-derived"`):
+ * the emitter fixtures are NORMALIZED `OtelSpanInput` records whose ATTRIBUTE
+ * KEYS are taken verbatim from each emitter's published span output (URLs +
+ * `sourceVersion` below); attribute VALUES are representative. They are derived
+ * from the emitters' documented conventions, NOT captured from a live export —
+ * raw OTLP-envelope capture + the AnyValue decoder are M2's scope. Each fixture
+ * records its source so M2 can swap in a live capture without changing keys.
+ */
+import type { LlmCallEvent, ToolUseEvent, TwinHttpEvent } from "../../recorder-events.js";
+import type { OtelSpanEvent } from "../span-event.js";
+import type { OtelSpanInput } from "../map-span.js";
+export type LegacyEventRecord = TwinHttpEvent | LlmCallEvent | ToolUseEvent;
+export type FixtureDerivedFrom = "documentation-derived" | "pome-internal" | "otel-spec" | "live-capture";
+export interface LegacyFixtureShimOptions {
+    run_id?: string;
+}
+export interface LegacyFixture {
+    name: string;
+    provenance: string;
+    derivedFrom: FixtureDerivedFrom;
+    legacy: LegacyEventRecord;
+    options: LegacyFixtureShimOptions;
+    expected: OtelSpanEvent;
+}
+export interface EmitterFixture {
+    name: string;
+    emitter: "traceloop" | "vercel-ai-sdk" | "pydantic-logfire";
+    provenance: string;
+    sourceVersion: string;
+    derivedFrom: FixtureDerivedFrom;
+    span: OtelSpanInput;
+}
+export interface TraceFixture {
+    name: string;
+    provenance: string;
+    derivedFrom: FixtureDerivedFrom;
+    spans: OtelSpanInput[];
+}
+export interface ExternalApiFixture {
+    name: string;
+    provenance: string;
+    derivedFrom: FixtureDerivedFrom;
+    span: OtelSpanInput;
+}
+export declare const LEGACY_FIXTURES: readonly LegacyFixture[];
+export declare const EMITTER_FIXTURES: readonly EmitterFixture[];
+export declare const TRACE_FIXTURES: readonly TraceFixture[];
+export declare const EXTERNAL_API_FIXTURES: readonly ExternalApiFixture[];