@ironbee-ai/cli 0.6.1 → 0.7.0

package/dist/analytics/projection.d.ts

@@ -0,0 +1,356 @@
+/**
+ * IronBee CLI — Analytics Projection
+ *
+ * Projects a slice of host transcript JSONL lines into a delta
+ * `SessionAnalytics`. Operates on a slice (not the full file) so
+ * incremental projection is cheap; emits no content (privacy fence).
+ *
+ * Inputs:
+ *   - parsed transcript lines (already JSON-parsed by transcript.ts)
+ *   - `startingTurnIndex`: 1-based assistant message index for the FIRST
+ *     assistant message in this slice. Used by the turn-bucket logic to
+ *     assign global turn buckets across multiple incremental projections.
+ *
+ * Output: `DeltaAnalytics` — same shape as `AccumulatedAnalytics` plus
+ * delta-local signals merge needs (`has_assistant_with_usage`,
+ * `closing_pending_tool_uses`, `closing_current_turn`).
+ *
+ * Privacy: the function reads everything (Bash command body, Edit
+ * old_string/new_string, Write content, tool_result.content, user msg
+ * text for classifier keyword matching) but emits ONLY counts, categories,
+ * paths, timestamps, byte sizes, and boolean flags. No raw text leaves
+ * this function. Per-tool / per-category attribution operate on the
+ * read-once-locally pattern.
+ */
+import { CategoryStats, CurrentTurnState, DeltaAnalytics, PendingToolUse, SessionTurnAnalytics, SessionTurnStepAnalytics, TranscriptSource, TurnCategory, TurnEndReason } from "./types";
+interface MessageUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+    /**
+     * Anthropic's split of cache_creation tokens by ephemeral tier.
+     * `cache_creation_input_tokens` is the SUM of these. We track them
+     * separately so 1h cache writes (more expensive) get billed at the
+     * correct rate. Many real agent loop sessions are dominated by 1h.
+     */
+    cache_creation?: {
+        ephemeral_5m_input_tokens?: number;
+        ephemeral_1h_input_tokens?: number;
+    };
+    /**
+     * Server-side tool use counts. `web_search_requests` is the only
+     * billable one currently — Anthropic charges $0.01 per request.
+     */
+    server_tool_use?: {
+        web_search_requests?: number;
+    };
+    /**
+     * Speed tier for fast-mode pricing. `"fast"` triggers the Opus 4.6
+     * fast tier (6× regular Opus 4.5+ rate). Any other value or undefined
+     * falls back to the model's regular pricing.
+     */
+    speed?: string;
+    /**
+     * Sub-iteration usages for compound calls (e.g. `advisor` server tool).
+     * Each entry typed `"advisor_message"` represents an advisor sub-call
+     * whose tokens are NOT in the parent `usage` totals — they're billed
+     * separately at their own model's rate. We loop these and add per-iter
+     * cost to the unattributed bucket. Other iteration types (`"message"`)
+     * mirror the parent usage and are ignored to avoid double counting.
+     */
+    iterations?: Array<{
+        type?: string;
+        model?: string;
+        input_tokens?: number;
+        output_tokens?: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
+        cache_creation?: {
+            ephemeral_5m_input_tokens?: number;
+            ephemeral_1h_input_tokens?: number;
+        };
+    }>;
+}
+interface MessageBody {
+    content?: unknown;
+    usage?: MessageUsage;
+    /**
+     * Model identifier on assistant messages (e.g. `"claude-opus-4-7"`).
+     * Sub-agent / skill turns may run on a different model than the host
+     * conversation, so we count per-message rather than picking one label.
+     */
+    model?: string;
+    /**
+     * Anthropic API message id (e.g. `"msg_01ABCdef..."`). Set on assistant
+     * messages by the API. Claude Code's transcript writer occasionally
+     * persists the same API response on multiple JSONL lines (different
+     * top-level `uuid`s but identical `message.id` + `requestId` + `usage`
+     * — likely stream finalization re-emit / per-tool_use re-serialization).
+     * Projection deduplicates by this field so a single API call counts
+     * once toward tokens / cost / per-tool attribution / step+turn opens.
+     * Without this, totals can be ~2x inflated on real sessions.
+     */
+    id?: string;
+}
+export interface RawTranscriptLine {
+    type?: string;
+    message?: MessageBody;
+    timestamp?: string;
+    /** Some Claude transcript versions include `cwd` on lines — currently unused. */
+    cwd?: string;
+    /**
+     * Claude Code marks host-injected user messages (slash command bodies,
+     * Stop-hook feedback strings, etc.) with this top-level boolean. Real
+     * user prompts do not carry it. This is the structurally robust signal
+     * we use to skip these lines from `isHumanTextUser` so they don't open
+     * synthetic user_turns. Content-based detection (keyword sniffing) was
+     * the prior approach — it was fragile across Claude Code wrapper format
+     * changes; `isMeta` is part of the documented JSONL schema.
+     */
+    isMeta?: boolean;
+    /**
+     * Top-level Anthropic API request id (e.g. `"req_011CaYGn..."`). Set on
+     * SUCCESSFUL assistant lines by Claude Code. Verified absent on every
+     * `isApiErrorMessage:true` line (transcript-side: failure lines carry no
+     * join key back to the original API request).
+     */
+    requestId?: string;
+    /**
+     * Top-level discriminator set on assistant lines representing a final
+     * API failure (after retry exhaustion). When `true`, `message.model` is
+     * `"<synthetic>"`, all `usage.*` token counts are zero, and the line
+     * carries `error` (and sometimes `apiErrorStatus`) at top level.
+     */
+    isApiErrorMessage?: boolean;
+    /**
+     * Top-level error category on `isApiErrorMessage:true` lines. Observed
+     * values: `"rate_limit"` / `"authentication_failed"` / `"server_error"`
+     * / `"unknown"`. Absent on success lines.
+     */
+    error?: string;
+    /**
+     * HTTP status code on `isApiErrorMessage:true` lines. Verified ~5%
+     * presence even on failure lines (only seen on explicit HTTP status
+     * errors like 429 rate-limit). Absent on success and most failures.
+     */
+    apiErrorStatus?: number;
+    /**
+     * Per-line UUID generated by Claude Code at line-write time. Verified
+     * 100% presence across all assistant lines (success + failure). Used
+     * as the deterministic `Event.id` for the api_request wire event so
+     * re-projections of the same transcript bytes produce identical event
+     * ids → backend can dedupe on `(session_id, id)` for both success
+     * (where `request_id` is also available) and failure (where it isn't).
+     */
+    uuid?: string;
+}
+export interface ProjectionInput {
+    /** The transcript lines we just parsed (only those with `parsed !== null` and matching shape are walked). */
+    lines: RawTranscriptLine[];
+    /** 1-based global turn index for the first assistant message in this slice. */
+    startingTurnIndex: number;
+    /** Used to set identity fields on the delta. */
+    sessionId: string;
+    /** Project name (basename of git root or project dir) — see `resolveProjectName` in `actions.ts`. */
+    projectName: string;
+    transcriptSource: TranscriptSource;
+    /**
+     * ms-since-epoch of the LAST assistant message seen in prior slices.
+     * Used to compute the user_response_times_ms gap to the first human-text
+     * user message of THIS slice. Pass `undefined` for the first ever slice.
+     */
+    priorLastAssistantTsMs?: number;
+    /**
+     * Pending tool_uses carried over from prior slices (a tool_use emitted
+     * in slice K may have its tool_result / consumer in slice K+1 or K+2).
+     * Keyed by `tool_use.id`. Pass `undefined` / `{}` for the first slice
+     * or when no in-flight tools.
+     */
+    priorPendingToolUses?: Record<string, PendingToolUse>;
+    /**
+     * ms-since-epoch of the most recent message timestamp seen across all
+     * prior slices (used to attribute the cross-slice gap to active vs
+     * idle: if THIS slice opens with a human-user message, the
+     * `firstMsg.ts - priorLastActivityTsMs` gap counts as user-idle).
+     *
+     * `undefined` for the first slice. Derived from
+     * `Date.parse(state.accumulated.last_activity_time)`.
+     */
+    priorLastActivityTsMs?: number;
+    /**
+     * In-flight per-turn classifier state from the prior slice. The turn
+     * may have been opened by a human-user msg in a prior slice and is
+     * still accumulating signals. The new slice OR's in its own signals;
+     * the turn closes when the next human-user msg arrives.
+     */
+    priorCurrentTurn?: CurrentTurnState;
+    /**
+     * Next turn_index to assign when a fresh turn opens. Carries the
+     * monotonic counter across slice boundaries. Defaults to 1 on the
+     * first slice. The projection consumes this seed and reports the
+     * post-walk value via `DeltaInternal.next_turn_index`.
+     */
+    priorNextTurnIndex?: number;
+    /**
+     * Anthropic API message ids already counted in prior slices. The projection
+     * skips any assistant line whose `message.id` is in this set (or appears
+     * twice in the current slice) so a single API response counted once
+     * regardless of how many times the transcript writer persisted it.
+     * Reported back via `DeltaInternal.seen_assistant_message_ids` and merged
+     * into `state.internal.seen_assistant_message_ids` for cross-slice continuity.
+     */
+    priorSeenAssistantMessageIds?: string[];
+}
+/**
+ * Deterministic turn id — `sha256(session_id|turn_index|start_time)`
+ * sliced to 16 hex chars. Re-emits of the same turn produce the same
+ * id, so backend LWW per `(session_id, turn_id)` is well-defined.
+ */
+/**
+ * Deterministic per-step identifier — `sha256(turn_id|step_index|start_time)`
+ * sliced to 16 hex chars. Same property as {@link deriveTurnId}: same
+ * inputs always map to the same id, so backend LWW per `(session_id,
+ * step_id)` is well-defined and re-emits are idempotent.
+ */
+export declare function deriveStepId(turnId: string, stepIndex: number, startTime: string): string;
+export declare function deriveTurnId(sessionId: string, turnIndex: number, startTime: string): string;
+/**
+ * Format a 32-char hex string into UUID-shaped layout (8-4-4-4-12). NOT
+ * RFC 4122-compliant (no version/variant bits) but matches the regex
+ * shape collectors expect for `Event.id`. Pure presentation — collisions
+ * impossible because the source hash space is the same 32 hex chars.
+ */
+export declare function formatHexAsUuid(hex32: string): string;
+/**
+ * Deterministic Event.id for `session_analytics` wire records.
+ * `sha256("session_analytics:" + session_id + ":" + offset)`, formatted as
+ * UUID. Re-emits of the same `(session_id, offset)` produce the same id —
+ * backend treats them as updates to the same logical checkpoint:
+ *   - First Stop @ offset=100 (`is_final=false`)            → row inserted
+ *   - SessionEnd @ offset=100 (carve-out, `is_final=true`)  → ON CONFLICT update
+ *   - Worker re-projects same slice after crash             → ON CONFLICT update
+ * `snapshot_at` is intentionally NOT in the id — it's metadata for
+ * tiebreaking on collision (`UPDATE ... WHERE EXCLUDED.snapshot_at >=
+ * stored.snapshot_at`). This keeps `(session_id, id)` as a uniform dedup
+ * key across all analytics event types.
+ */
+export declare function deriveSessionAnalyticsEventId(sessionId: string, offset: number): string;
+/**
+ * Deterministic Event.id for `session_turn_analytics` wire records.
+ * Derives from the turn's deterministic `turn_id` namespaced under the
+ * session — re-emits of the same turn produce the same Event.id.
+ */
+export declare function deriveTurnEventId(sessionId: string, turnId: string): string;
+/**
+ * Deterministic Event.id for `session_turn_step_analytics` wire records.
+ * Same pattern as {@link deriveTurnEventId} — derives from the step's
+ * deterministic `step_id` namespaced under the session. Re-emits idempotent.
+ */
+export declare function deriveStepEventId(sessionId: string, stepId: string): string;
+/**
+ * Options for {@link closeTurn} — bundles the projection-time identity
+ * fields + boundary metadata. Bundled into an object to keep the call
+ * sites readable (the alternative is a 7-positional-arg call).
+ */
+export interface CloseTurnOpts {
+    endTime: string;
+    endReason: TurnEndReason;
+    sessionId: string;
+    projectName: string;
+    transcriptSource: TranscriptSource;
+}
+/**
+ * Per-category-breakdown delta produced by closing one turn. Cleanly
+ * separable from the caller's accumulator state — caller applies via
+ * {@link applyBreakdownDelta} or its own merge logic. Keeps `closeTurn`
+ * a pure function with no input mutation.
+ */
+export interface CloseTurnResult {
+    category: TurnCategory;
+    turns_with_retry_inc: number;
+    one_shot_inc: number;
+    breakdown_delta: {
+        turns_inc: number;
+        turns_with_edit_inc: number;
+        total_retries_inc: number;
+        cost_usd_inc: number;
+    };
+    turn_event: SessionTurnAnalytics;
+    /**
+     * Per-step events for every step that ran in this turn, in
+     * `(turn_index, step_index)` order. The LAST entry carries
+     * `is_last_step=true` plus the turn-bookend fields
+     * (`turn_end_reason`, `turn_end_time`, `turn_duration`,
+     * `turn_category`, `turn_was_one_shot`, `turn_was_interrupted`)
+     * — backend reads `is_last_step=true` to know "this turn is now
+     * fully reconstructable from steps."
+     *
+     * Empty when the turn had no assistant message (defensive — should
+     * not happen in a normal transcript but we tolerate it).
+     */
+    step_events: SessionTurnStepAnalytics[];
+}
+/**
+ * Apply a {@link CloseTurnResult}'s `breakdown_delta` onto a category-
+ * breakdown map. Always WRITES A FRESH SLOT — never mutates the existing
+ * one in place. This decouples the post-merge mutation in emit.ts's
+ * finalize block from the slot-reference assumptions of any future
+ * `mergeCategoryBreakdown` refactor.
+ */
+export declare function applyBreakdownDelta(breakdown: Record<string, CategoryStats>, r: CloseTurnResult): void;
+/**
+ * Close a turn — finalizes the per-turn record, runs the classifier,
+ * and produces a fully-built `SessionTurnAnalytics` for the wire plus
+ * the per-category breakdown delta the caller should apply.
+ *
+ * Pure function — does not mutate any input. `opts.endTime` is the
+ * closing event timestamp (next human-user msg, or session_end when
+ * finalizing). `opts.endReason` records which boundary fired so backend
+ * can distinguish normal turn ends from session-end forced closes.
+ */
+export declare function closeTurn(turn: CurrentTurnState, opts: CloseTurnOpts): CloseTurnResult;
+export declare function projectDelta(input: ProjectionInput): DeltaAnalytics;
+/** Exposed for the merge step + tests — the per-delta top-K map. */
+export interface DeltaInternal {
+    file_path_change_counts: Record<string, number>;
+    distinct_file_paths_seen: string[];
+    /**
+     * ms-since-epoch of the LAST assistant message timestamp seen in this
+     * slice. Used by merge to update `internal.last_assistant_ts_ms` so the
+     * NEXT slice's projection can seed `priorLastAssistantTsMs` and compute
+     * cross-slice user-response-time gaps.
+     */
+    last_assistant_ts_ms?: number;
+    /**
+     * Idle ms accumulated WITHIN this slice — sum of `(human_user.ts - prior.ts)`
+     * gaps. Includes the cross-slice gap when this slice opens with a
+     * human-user message and `priorLastActivityTsMs` was supplied. Merge
+     * adds this to `internal.idle_ms_total` and recomputes
+     * `accumulated.idle_minutes` + `accumulated.active_minutes`.
+     */
+    idle_ms_delta?: number;
+    /**
+     * Post-walk value of the monotonic per-session turn index. Merge
+     * persists this into `state.internal.next_turn_index` so the next
+     * slice's projection seeds `priorNextTurnIndex` from it.
+     */
+    next_turn_index?: number;
+    /**
+     * Anthropic message ids newly counted in THIS slice (not present in
+     * priorSeenAssistantMessageIds). Merge appends these to
+     * `state.internal.seen_assistant_message_ids` so the next slice can
+     * detect cross-slice duplicate API responses.
+     */
+    new_assistant_message_ids?: string[];
+}
+/**
+ * Re-walk the same lines to extract the per-delta internal aggregation
+ * fields (path→count map + distinct set + last assistant timestamp) the
+ * merge step needs to update `internal.*` on the state file. Kept separate
+ * so the wire-level `DeltaAnalytics` (sent through merge) doesn't carry
+ * these maps.
+ */
+export declare function projectDeltaInternal(input: ProjectionInput): DeltaInternal;
+export {};
+//# sourceMappingURL=projection.d.ts.map

package/dist/analytics/projection.d.ts.map

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