@bli-cockpit/telemetry-core 0.1.0

package/dist/source-adapter.d.ts

@@ -0,0 +1,235 @@
+import { z } from "zod";
+export declare const SourceAdapterIdentitySchema: z.ZodObject<{
+    capture_source: z.ZodEnum<{
+        unknown: "unknown";
+        codex_jsonl: "codex_jsonl";
+        codex_otel: "codex_otel";
+        car_state: "car_state";
+        git_state: "git_state";
+        github_state: "github_state";
+        linear_state: "linear_state";
+        mcp_local: "mcp_local";
+        claude_hooks: "claude_hooks";
+        manual_event: "manual_event";
+        collector_runtime: "collector_runtime";
+    }>;
+    adapter_name: z.ZodString;
+    capture_adapter_version: z.ZodString;
+}, z.core.$strict>;
+export type SourceAdapterIdentity = z.infer<typeof SourceAdapterIdentitySchema>;
+export declare const SourceScanEventSummarySchema: z.ZodObject<{
+    source_event_id: z.ZodString;
+    event_type: z.ZodString;
+    occurred_at: z.ZodOptional<z.ZodString>;
+    redaction: z.ZodObject<{
+        privacy_classification: z.ZodEnum<{
+            metadata: "metadata";
+            redacted_summary: "redacted_summary";
+            local_only_raw_evidence: "local_only_raw_evidence";
+            remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+        }>;
+        redaction_status: z.ZodEnum<{
+            metadata_only: "metadata_only";
+            redacted: "redacted";
+            raw_local_only: "raw_local_only";
+            raw_remote_short_retention: "raw_remote_short_retention";
+        }>;
+        redacted_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        raw_evidence_pointer_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        content_hash_sha256: z.ZodOptional<z.ZodString>;
+        redacted_summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    raw_evidence_pointers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        raw_evidence_pointer_id: z.ZodString;
+        privacy_classification: z.ZodEnum<{
+            local_only_raw_evidence: "local_only_raw_evidence";
+            remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+        }>;
+        retention_policy: z.ZodObject<{
+            mode: z.ZodEnum<{
+                local_only: "local_only";
+                remote_short_retention: "remote_short_retention";
+            }>;
+            privacy_classification: z.ZodEnum<{
+                local_only_raw_evidence: "local_only_raw_evidence";
+                remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+            }>;
+            remote_retention_days: z.ZodOptional<z.ZodNumber>;
+            expires_at: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        storage_scope: z.ZodEnum<{
+            local_file: "local_file";
+            remote_object: "remote_object";
+        }>;
+        local_path: z.ZodOptional<z.ZodString>;
+        object_key: z.ZodOptional<z.ZodString>;
+        content_hash_sha256: z.ZodOptional<z.ZodString>;
+        byte_size: z.ZodOptional<z.ZodNumber>;
+        media_type: z.ZodOptional<z.ZodString>;
+        redacted_summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type SourceScanEventSummary = z.infer<typeof SourceScanEventSummarySchema>;
+export declare const SourceScanResultSchema: z.ZodObject<{
+    adapter: z.ZodObject<{
+        capture_source: z.ZodEnum<{
+            unknown: "unknown";
+            codex_jsonl: "codex_jsonl";
+            codex_otel: "codex_otel";
+            car_state: "car_state";
+            git_state: "git_state";
+            github_state: "github_state";
+            linear_state: "linear_state";
+            mcp_local: "mcp_local";
+            claude_hooks: "claude_hooks";
+            manual_event: "manual_event";
+            collector_runtime: "collector_runtime";
+        }>;
+        adapter_name: z.ZodString;
+        capture_adapter_version: z.ZodString;
+    }, z.core.$strict>;
+    work_context_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        ok: "ok";
+        partial: "partial";
+        skipped: "skipped";
+        failed: "failed";
+    }>;
+    started_at: z.ZodString;
+    finished_at: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    events: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source_event_id: z.ZodString;
+        event_type: z.ZodString;
+        occurred_at: z.ZodOptional<z.ZodString>;
+        redaction: z.ZodObject<{
+            privacy_classification: z.ZodEnum<{
+                metadata: "metadata";
+                redacted_summary: "redacted_summary";
+                local_only_raw_evidence: "local_only_raw_evidence";
+                remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+            }>;
+            redaction_status: z.ZodEnum<{
+                metadata_only: "metadata_only";
+                redacted: "redacted";
+                raw_local_only: "raw_local_only";
+                raw_remote_short_retention: "raw_remote_short_retention";
+            }>;
+            redacted_fields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            raw_evidence_pointer_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            content_hash_sha256: z.ZodOptional<z.ZodString>;
+            redacted_summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        raw_evidence_pointers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            raw_evidence_pointer_id: z.ZodString;
+            privacy_classification: z.ZodEnum<{
+                local_only_raw_evidence: "local_only_raw_evidence";
+                remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+            }>;
+            retention_policy: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    local_only: "local_only";
+                    remote_short_retention: "remote_short_retention";
+                }>;
+                privacy_classification: z.ZodEnum<{
+                    local_only_raw_evidence: "local_only_raw_evidence";
+                    remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+                }>;
+                remote_retention_days: z.ZodOptional<z.ZodNumber>;
+                expires_at: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            storage_scope: z.ZodEnum<{
+                local_file: "local_file";
+                remote_object: "remote_object";
+            }>;
+            local_path: z.ZodOptional<z.ZodString>;
+            object_key: z.ZodOptional<z.ZodString>;
+            content_hash_sha256: z.ZodOptional<z.ZodString>;
+            byte_size: z.ZodOptional<z.ZodNumber>;
+            media_type: z.ZodOptional<z.ZodString>;
+            redacted_summary: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    ticket_binding_candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ticket_id: z.ZodString;
+        binding_source: z.ZodEnum<{
+            active_work_context: "active_work_context";
+            branch_name: "branch_name";
+            linear_assignment: "linear_assignment";
+            car_ticket: "car_ticket";
+            github_pr: "github_pr";
+            mcp_context: "mcp_context";
+            manual_picker: "manual_picker";
+        }>;
+        confidence: z.ZodNumber;
+        evidence_labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        external_url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    risk_flags: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        risk_flag_id: z.ZodString;
+        risk_type: z.ZodEnum<{
+            no_plan_signal_before_large_edit: "no_plan_signal_before_large_edit";
+            p1_or_p2_review_finding: "p1_or_p2_review_finding";
+            many_add_revert_loops: "many_add_revert_loops";
+            repeated_same_tool_input_shape: "repeated_same_tool_input_shape";
+            tool_call_loop: "tool_call_loop";
+            file_thrash_same_path: "file_thrash_same_path";
+            context_window_pressure: "context_window_pressure";
+            permission_denied_spike: "permission_denied_spike";
+            high_token_or_time_burn_no_pr: "high_token_or_time_burn_no_pr";
+            stuck_for_30_minutes: "stuck_for_30_minutes";
+            repeated_same_failing_command: "repeated_same_failing_command";
+            branch_ticket_mismatch: "branch_ticket_mismatch";
+            collector_stale: "collector_stale";
+        }>;
+        severity: z.ZodEnum<{
+            info: "info";
+            warning: "warning";
+            high: "high";
+        }>;
+        observed_at: z.ZodString;
+        evidence_labels: z.ZodArray<z.ZodEnum<{
+            missing_plan_signal: "missing_plan_signal";
+            large_edit: "large_edit";
+            p1_review_finding: "p1_review_finding";
+            p2_review_finding: "p2_review_finding";
+            add_revert_loop: "add_revert_loop";
+            same_tool_input_shape: "same_tool_input_shape";
+            tool_call_loop_window: "tool_call_loop_window";
+            same_path_churn: "same_path_churn";
+            token_pressure: "token_pressure";
+            permission_denied: "permission_denied";
+            approval_denied: "approval_denied";
+            no_pr_after_work: "no_pr_after_work";
+            idle_or_stuck_duration: "idle_or_stuck_duration";
+            same_failing_command: "same_failing_command";
+            branch_ticket_disagreement: "branch_ticket_disagreement";
+            collector_last_seen_stale: "collector_last_seen_stale";
+        }>>;
+        evidence_pointer_ids: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        provenance: z.ZodObject<{
+            capture_source: z.ZodEnum<{
+                unknown: "unknown";
+                codex_jsonl: "codex_jsonl";
+                codex_otel: "codex_otel";
+                car_state: "car_state";
+                git_state: "git_state";
+                github_state: "github_state";
+                linear_state: "linear_state";
+                mcp_local: "mcp_local";
+                claude_hooks: "claude_hooks";
+                manual_event: "manual_event";
+                collector_runtime: "collector_runtime";
+            }>;
+            capture_adapter_version: z.ZodString;
+            collector_version: z.ZodString;
+            repo: z.ZodString;
+            branch: z.ZodString;
+            operator_id: z.ZodString;
+            session_id: z.ZodString;
+            work_context_id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    diagnostic_labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type SourceScanResult = z.infer<typeof SourceScanResultSchema>;

package/dist/source-adapter.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { CaptureSourceSchema, IsoDateTimeSchema, NonEmptyStringSchema, VersionStringSchema, } from "./common.js";
+import { RawEvidencePointerSchema, RedactionMetadataSchema } from "./privacy.js";
+import { RiskFlagSchema } from "./risk-flags.js";
+import { TicketBindingCandidateSchema } from "./work-context.js";
+export const SourceAdapterIdentitySchema = z
+    .object({
+    capture_source: CaptureSourceSchema,
+    adapter_name: NonEmptyStringSchema,
+    capture_adapter_version: VersionStringSchema,
+})
+    .strict();
+export const SourceScanEventSummarySchema = z
+    .object({
+    source_event_id: NonEmptyStringSchema,
+    event_type: NonEmptyStringSchema,
+    occurred_at: IsoDateTimeSchema.optional(),
+    redaction: RedactionMetadataSchema,
+    raw_evidence_pointers: z.array(RawEvidencePointerSchema).default([]),
+})
+    .strict();
+export const SourceScanResultSchema = z
+    .object({
+    adapter: SourceAdapterIdentitySchema,
+    work_context_id: NonEmptyStringSchema.optional(),
+    status: z.enum(["ok", "partial", "skipped", "failed"]),
+    started_at: IsoDateTimeSchema,
+    finished_at: IsoDateTimeSchema.optional(),
+    cursor: NonEmptyStringSchema.optional(),
+    events: z.array(SourceScanEventSummarySchema).default([]),
+    ticket_binding_candidates: z
+        .array(TicketBindingCandidateSchema)
+        .default([]),
+    risk_flags: z.array(RiskFlagSchema).default([]),
+    diagnostic_labels: z.array(NonEmptyStringSchema).default([]),
+})
+    .strict();

package/dist/trace-sink.d.ts

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import type { TelemetryIngestEnvelope } from "./ingest-dto.js";
+export declare const NormalizedOtelTelemetrySchema: z.ZodObject<{
+    trace_id: z.ZodOptional<z.ZodString>;
+    span_id: z.ZodOptional<z.ZodString>;
+    parent_span_id: z.ZodOptional<z.ZodString>;
+    span_name: z.ZodOptional<z.ZodString>;
+    span_kind: z.ZodOptional<z.ZodEnum<{
+        internal: "internal";
+        server: "server";
+        client: "client";
+        producer: "producer";
+        consumer: "consumer";
+    }>>;
+    log_severity: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>]>>>;
+}, z.core.$strict>;
+export type NormalizedOtelTelemetry = z.infer<typeof NormalizedOtelTelemetrySchema>;
+export declare const ExternalTraceSinkProviderSchema: z.ZodEnum<{
+    custom: "custom";
+    otel_collector: "otel_collector";
+    langfuse: "langfuse";
+    phoenix: "phoenix";
+    datadog: "datadog";
+    honeycomb: "honeycomb";
+}>;
+export type ExternalTraceSinkProvider = z.infer<typeof ExternalTraceSinkProviderSchema>;
+export declare const ExternalTraceSinkPointerSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        custom: "custom";
+        otel_collector: "otel_collector";
+        langfuse: "langfuse";
+        phoenix: "phoenix";
+        datadog: "datadog";
+        honeycomb: "honeycomb";
+    }>;
+    trace_id: z.ZodOptional<z.ZodString>;
+    span_id: z.ZodOptional<z.ZodString>;
+    external_url: z.ZodOptional<z.ZodString>;
+    project_id: z.ZodOptional<z.ZodString>;
+    exported_at: z.ZodOptional<z.ZodString>;
+    privacy_classification: z.ZodDefault<z.ZodEnum<{
+        metadata: "metadata";
+        redacted_summary: "redacted_summary";
+        local_only_raw_evidence: "local_only_raw_evidence";
+        remote_short_retention_raw_evidence: "remote_short_retention_raw_evidence";
+    }>>;
+}, z.core.$strict>;
+export type ExternalTraceSinkPointer = z.infer<typeof ExternalTraceSinkPointerSchema>;
+export interface TraceSinkWriteResult {
+    accepted_event_count: number;
+    pointer?: ExternalTraceSinkPointer;
+}
+export interface TraceSink {
+    readonly sink_id: string;
+    readonly provider: ExternalTraceSinkProvider;
+    writeEnvelope(envelope: TelemetryIngestEnvelope): Promise<TraceSinkWriteResult>;
+}

package/dist/trace-sink.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { IsoDateTimeSchema, JsonAttributeRecordSchema, NonEmptyStringSchema, } from "./common.js";
+import { PrivacyClassificationSchema } from "./privacy.js";
+export const NormalizedOtelTelemetrySchema = z
+    .object({
+    trace_id: NonEmptyStringSchema.optional(),
+    span_id: NonEmptyStringSchema.optional(),
+    parent_span_id: NonEmptyStringSchema.optional(),
+    span_name: NonEmptyStringSchema.optional(),
+    span_kind: z
+        .enum(["internal", "server", "client", "producer", "consumer"])
+        .optional(),
+    log_severity: NonEmptyStringSchema.optional(),
+    attributes: JsonAttributeRecordSchema.default({}),
+})
+    .strict();
+export const ExternalTraceSinkProviderSchema = z.enum([
+    "otel_collector",
+    "langfuse",
+    "phoenix",
+    "datadog",
+    "honeycomb",
+    "custom",
+]);
+export const ExternalTraceSinkPointerSchema = z
+    .object({
+    provider: ExternalTraceSinkProviderSchema,
+    trace_id: NonEmptyStringSchema.optional(),
+    span_id: NonEmptyStringSchema.optional(),
+    external_url: z.string().url().optional(),
+    project_id: NonEmptyStringSchema.optional(),
+    exported_at: IsoDateTimeSchema.optional(),
+    privacy_classification: PrivacyClassificationSchema.default("metadata"),
+})
+    .strict();

package/dist/work-context.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+export declare const TicketBindingSourceSchema: z.ZodEnum<{
+    active_work_context: "active_work_context";
+    branch_name: "branch_name";
+    linear_assignment: "linear_assignment";
+    car_ticket: "car_ticket";
+    github_pr: "github_pr";
+    mcp_context: "mcp_context";
+    manual_picker: "manual_picker";
+}>;
+export type TicketBindingSource = z.infer<typeof TicketBindingSourceSchema>;
+export declare const TicketBindingCandidateSchema: z.ZodObject<{
+    ticket_id: z.ZodString;
+    binding_source: z.ZodEnum<{
+        active_work_context: "active_work_context";
+        branch_name: "branch_name";
+        linear_assignment: "linear_assignment";
+        car_ticket: "car_ticket";
+        github_pr: "github_pr";
+        mcp_context: "mcp_context";
+        manual_picker: "manual_picker";
+    }>;
+    confidence: z.ZodNumber;
+    evidence_labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    external_url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TicketBindingCandidate = z.infer<typeof TicketBindingCandidateSchema>;
+export declare const LocalWorkContextSchema: z.ZodObject<{
+    work_context_id: z.ZodString;
+    repo: z.ZodString;
+    branch: z.ZodString;
+    operator_id: z.ZodString;
+    session_id: z.ZodString;
+    started_at: z.ZodString;
+    updated_at: z.ZodOptional<z.ZodString>;
+    active_ticket_id: z.ZodOptional<z.ZodString>;
+    ticket_binding_candidates: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        ticket_id: z.ZodString;
+        binding_source: z.ZodEnum<{
+            active_work_context: "active_work_context";
+            branch_name: "branch_name";
+            linear_assignment: "linear_assignment";
+            car_ticket: "car_ticket";
+            github_pr: "github_pr";
+            mcp_context: "mcp_context";
+            manual_picker: "manual_picker";
+        }>;
+        confidence: z.ZodNumber;
+        evidence_labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        external_url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    pull_request_url: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        capture_source: z.ZodEnum<{
+            unknown: "unknown";
+            codex_jsonl: "codex_jsonl";
+            codex_otel: "codex_otel";
+            car_state: "car_state";
+            git_state: "git_state";
+            github_state: "github_state";
+            linear_state: "linear_state";
+            mcp_local: "mcp_local";
+            claude_hooks: "claude_hooks";
+            manual_event: "manual_event";
+            collector_runtime: "collector_runtime";
+        }>;
+        capture_adapter_version: z.ZodString;
+        collector_version: z.ZodString;
+        repo: z.ZodString;
+        branch: z.ZodString;
+        operator_id: z.ZodString;
+        session_id: z.ZodString;
+        work_context_id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LocalWorkContext = z.infer<typeof LocalWorkContextSchema>;

package/dist/work-context.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { IsoDateTimeSchema, NonEmptyStringSchema, CaptureProvenanceSchema, } from "./common.js";
+export const TicketBindingSourceSchema = z.enum([
+    "active_work_context",
+    "branch_name",
+    "linear_assignment",
+    "car_ticket",
+    "github_pr",
+    "mcp_context",
+    "manual_picker",
+]);
+export const TicketBindingCandidateSchema = z
+    .object({
+    ticket_id: NonEmptyStringSchema,
+    binding_source: TicketBindingSourceSchema,
+    confidence: z.number().min(0).max(1),
+    evidence_labels: z.array(NonEmptyStringSchema).default([]),
+    external_url: z.string().url().optional(),
+})
+    .strict();
+export const LocalWorkContextSchema = z
+    .object({
+    work_context_id: NonEmptyStringSchema,
+    repo: NonEmptyStringSchema,
+    branch: NonEmptyStringSchema,
+    operator_id: NonEmptyStringSchema,
+    session_id: NonEmptyStringSchema,
+    started_at: IsoDateTimeSchema,
+    updated_at: IsoDateTimeSchema.optional(),
+    active_ticket_id: NonEmptyStringSchema.optional(),
+    ticket_binding_candidates: z
+        .array(TicketBindingCandidateSchema)
+        .default([]),
+    pull_request_url: z.string().url().optional(),
+    provenance: CaptureProvenanceSchema.optional(),
+})
+    .strict();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@bli-cockpit/telemetry-core",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepack": "rm -rf dist && tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "20.19.39",
+    "typescript": "5.9.3",
+    "vitest": "3.2.4"
+  }
+}