@ironbee-ai/cli 0.6.2 → 0.7.0

package/dist/import/filter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * IronBee CLI — Import Module Time-Range Filter
+ *
+ * Two-pass filter:
+ *   1. mtime — drop transcripts whose `mtimeMs` falls outside [from, to].
+ *      Already filtered at discovery time (statSync), so no extra I/O here.
+ *   2. session-start timestamp — drop transcripts whose first-line
+ *      `timestamp` is outside the window. Already on the target (read at
+ *      discovery time), so this step is also pure logic.
+ *
+ * Also exports `parseSinceDuration` for `--since 30d` / `2w` / `6m` style
+ * inputs, and `parseIsoDate` for `--from` / `--to`.
+ *
+ *
+ */
+import { ImportTarget, ImportTimeRange } from "./types";
+/**
+ * Apply both passes. Targets whose mtime AND first-line timestamp both fall
+ * inside the window survive. Empty range (`null`) → no filter, all pass.
+ *
+ * The mtime check is the **outer** gate (we'd discover sessions whose mtime
+ * is in-range but whose start is out-of-range — those still pass mtime, fail
+ * start-timestamp). The start-timestamp check is the **inner** gate that
+ * makes `--from / --to` strict.
+ */
+export declare function applyTimeRange(targets: ImportTarget[], range: ImportTimeRange | null): ImportTarget[];
+/**
+ * Parse `--since 30d` / `2w` / `6m` / `12h` into ms. Returns `null` when the
+ * input is malformed or zero/negative.
+ *
+ * Suffixes: `h` (hour), `d` (day), `w` (7-day week), `m` (30-day month).
+ */
+export declare function parseSinceDuration(input: string): number | null;
+/**
+ * Parse an ISO date string (`2025-04-15` or `2025-04-15T12:00:00Z`).
+ * Returns `null` when unparseable. Date-only inputs resolve to local
+ * midnight (matches the analytics `messages_by_date` convention).
+ */
+export declare function parseIsoDate(input: string): number | null;
+/** Build an `ImportTimeRange` from `--since` / `--from / --to` flags. */
+export declare function buildTimeRange(opts: {
+    sinceMs?: number;
+    fromMs?: number;
+    toMs?: number;
+    nowMs: number;
+}): ImportTimeRange | null;
+//# sourceMappingURL=filter.d.ts.map

package/dist/import/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/import/filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAExD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,YAAY,EAAE,CAarG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmB/D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGzD;AAED,yEAAyE;AACzE,wBAAgB,cAAc,CAAC,IAAI,EAAE;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB,GAAG,eAAe,GAAG,IAAI,CAQzB"}

package/dist/import/filter.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Time-Range Filter
+ *
+ * Two-pass filter:
+ *   1. mtime — drop transcripts whose `mtimeMs` falls outside [from, to].
+ *      Already filtered at discovery time (statSync), so no extra I/O here.
+ *   2. session-start timestamp — drop transcripts whose first-line
+ *      `timestamp` is outside the window. Already on the target (read at
+ *      discovery time), so this step is also pure logic.
+ *
+ * Also exports `parseSinceDuration` for `--since 30d` / `2w` / `6m` style
+ * inputs, and `parseIsoDate` for `--from` / `--to`.
+ *
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTimeRange = applyTimeRange;
+exports.parseSinceDuration = parseSinceDuration;
+exports.parseIsoDate = parseIsoDate;
+exports.buildTimeRange = buildTimeRange;
+/**
+ * Apply both passes. Targets whose mtime AND first-line timestamp both fall
+ * inside the window survive. Empty range (`null`) → no filter, all pass.
+ *
+ * The mtime check is the **outer** gate (we'd discover sessions whose mtime
+ * is in-range but whose start is out-of-range — those still pass mtime, fail
+ * start-timestamp). The start-timestamp check is the **inner** gate that
+ * makes `--from / --to` strict.
+ */
+function applyTimeRange(targets, range) {
+    if (range === null) {
+        return targets;
+    }
+    return targets.filter((t) => {
+        if (t.mtimeMs < range.fromMs || t.mtimeMs > range.toMs) {
+            return false;
+        }
+        if (t.sessionStartMs < range.fromMs || t.sessionStartMs > range.toMs) {
+            return false;
+        }
+        return true;
+    });
+}
+/**
+ * Parse `--since 30d` / `2w` / `6m` / `12h` into ms. Returns `null` when the
+ * input is malformed or zero/negative.
+ *
+ * Suffixes: `h` (hour), `d` (day), `w` (7-day week), `m` (30-day month).
+ */
+function parseSinceDuration(input) {
+    const m = input.match(/^(\d+)([hdwm])$/);
+    if (m === null) {
+        return null;
+    }
+    const value = parseInt(m[1], 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    const unit = m[2];
+    const HOUR_MS = 60 * 60 * 1000;
+    const DAY_MS = 24 * HOUR_MS;
+    switch (unit) {
+        case "h": return value * HOUR_MS;
+        case "d": return value * DAY_MS;
+        case "w": return value * 7 * DAY_MS;
+        case "m": return value * 30 * DAY_MS;
+        default: return null;
+    }
+}
+/**
+ * Parse an ISO date string (`2025-04-15` or `2025-04-15T12:00:00Z`).
+ * Returns `null` when unparseable. Date-only inputs resolve to local
+ * midnight (matches the analytics `messages_by_date` convention).
+ */
+function parseIsoDate(input) {
+    const ts = Date.parse(input);
+    return Number.isFinite(ts) ? ts : null;
+}
+/** Build an `ImportTimeRange` from `--since` / `--from / --to` flags. */
+function buildTimeRange(opts) {
+    if (opts.sinceMs !== undefined) {
+        return { fromMs: opts.nowMs - opts.sinceMs, toMs: opts.nowMs };
+    }
+    if (opts.fromMs !== undefined) {
+        return { fromMs: opts.fromMs, toMs: opts.toMs ?? opts.nowMs };
+    }
+    return null;
+}
+//# sourceMappingURL=filter.js.map

package/dist/import/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../src/import/filter.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAaH,wCAaC;AAQD,gDAmBC;AAOD,oCAGC;AAGD,wCAaC;AA3ED;;;;;;;;GAQG;AACH,SAAgB,cAAc,CAAC,OAAuB,EAAE,KAA6B;IACjF,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QACjB,OAAO,OAAO,CAAC;IACnB,CAAC;IACD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAe,EAAW,EAAE;QAC/C,IAAI,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YACrD,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,CAAC,cAAc,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC,cAAc,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YACnE,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC,CAAC,CAAC;AACP,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,KAAa;IAC5C,MAAM,CAAC,GAA4B,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAClE,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;QACb,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,KAAK,GAAW,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,MAAM,IAAI,GAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,OAAO,GAAW,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IACvC,MAAM,MAAM,GAAW,EAAE,GAAG,OAAO,CAAC;IACpC,QAAQ,IAAI,EAAE,CAAC;QACX,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,OAAO,CAAC;QACjC,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,MAAM,CAAC;QAChC,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,CAAC,GAAG,MAAM,CAAC;QACpC,KAAK,GAAG,CAAC,CAAC,OAAO,KAAK,GAAG,EAAE,GAAG,MAAM,CAAC;QACrC,OAAO,CAAC,CAAC,OAAO,IAAI,CAAC;IACzB,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,KAAa;IACtC,MAAM,EAAE,GAAW,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACrC,OAAO,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC3C,CAAC;AAED,yEAAyE;AACzE,SAAgB,cAAc,CAAC,IAK9B;IACG,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;IACnE,CAAC;IACD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;IAClE,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC"}

package/dist/import/ids.d.ts

@@ -0,0 +1,56 @@
+/**
+ * IronBee CLI — Import Module Deterministic UUID Derivers
+ *
+ * Every event emitted by `ironbee import` carries a UUID-shaped `id` derived
+ * deterministically from the transcript content (session_id + per-event
+ * positional key). Re-running import on the same transcript produces the
+ * same ids, so collector-side dedup on `(session_id, id)` collapses
+ * duplicates without coordination.
+ *
+ * Analytics events have their own deriver in `src/analytics/projection.ts`
+ * (`deriveSessionAnalyticsEventId`, `deriveTurnEventId`, `deriveStepEventId`).
+ * This module covers the non-analytics import-emitted events: session,
+ * activity, tool_call, file_change.
+ *
+ * All formulas: `formatHexAsUuid(sha256("<event_type>:" + session_id + ":"
+ * + <positional_key>))` — positional key is `turn_index` for activity ids
+ * and `tool_use.id` for tool_call / file_change. Same `(transcript content,
+ * session_id)` always produces the same UUID.
+ */
+export declare function deriveSessionStartEventId(sessionId: string): string;
+export declare function deriveSessionEndEventId(sessionId: string): string;
+/**
+ * Activity (turn) ids. `turnIndex` is the analytics-side `turn_index` (1-based,
+ * positional in the transcript). Activity is one-per-user-turn: host_inject
+ * continuation turns are filtered out before we ever derive an id, so there
+ * are no gaps from the import emitter's perspective.
+ */
+export declare function deriveActivityStartEventId(sessionId: string, turnIndex: number): string;
+export declare function deriveActivityEndEventId(sessionId: string, turnIndex: number): string;
+/**
+/**
+ * Activity-id (the `activity_id` foreign key carried by child events).
+ *
+ * Format: UUID-shaped (8-4-4-4-12) — matches what live mode emits (live
+ * uses `randomUUID()` at the SessionStart hook, baked into `state.json`,
+ * then read by every PreToolUse). Backends that store `activity_id` as a
+ * UUID column accept both live and import values uniformly.
+ *
+ * Determinism: same `(session_id, turn_index, start_time)` tuple always
+ * produces the same UUID, so re-imports collide cleanly. Independent of
+ * `session_turn_analytics.turn_id` (which keeps its 16-char hex form per
+ * analytics spec) — they're separate identifiers for related-but-distinct
+ * concepts (hook-runtime activity vs. analytics-projection turn).
+ */
+export declare function deriveActivityId(sessionId: string, turnIndex: number, startTime: string): string;
+/**
+ * Default tool_call event id when `_metadata.toolCallId` is absent (transcript
+ * predates the `_metadata.toolCallId` convention). Falls back to a
+ * deterministic derivation from the host's `tool_use.id`. For transcripts
+ * that DO carry `_metadata.toolCallId`, the import emitter uses that
+ * UUID verbatim instead — collapses cleanly with the live MCP-shipped
+ * event id on the collector.
+ */
+export declare function deriveToolCallEventIdFromToolUseId(sessionId: string, toolUseId: string): string;
+export declare function deriveFileChangeEventId(sessionId: string, toolUseId: string): string;
+//# sourceMappingURL=ids.d.ts.map

package/dist/import/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/import/ids.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAWH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAErF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGhG;AAED;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/F;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpF"}

package/dist/import/ids.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Deterministic UUID Derivers
+ *
+ * Every event emitted by `ironbee import` carries a UUID-shaped `id` derived
+ * deterministically from the transcript content (session_id + per-event
+ * positional key). Re-running import on the same transcript produces the
+ * same ids, so collector-side dedup on `(session_id, id)` collapses
+ * duplicates without coordination.
+ *
+ * Analytics events have their own deriver in `src/analytics/projection.ts`
+ * (`deriveSessionAnalyticsEventId`, `deriveTurnEventId`, `deriveStepEventId`).
+ * This module covers the non-analytics import-emitted events: session,
+ * activity, tool_call, file_change.
+ *
+ * All formulas: `formatHexAsUuid(sha256("<event_type>:" + session_id + ":"
+ * + <positional_key>))` — positional key is `turn_index` for activity ids
+ * and `tool_use.id` for tool_call / file_change. Same `(transcript content,
+ * session_id)` always produces the same UUID.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSessionStartEventId = deriveSessionStartEventId;
+exports.deriveSessionEndEventId = deriveSessionEndEventId;
+exports.deriveActivityStartEventId = deriveActivityStartEventId;
+exports.deriveActivityEndEventId = deriveActivityEndEventId;
+exports.deriveActivityId = deriveActivityId;
+exports.deriveToolCallEventIdFromToolUseId = deriveToolCallEventIdFromToolUseId;
+exports.deriveFileChangeEventId = deriveFileChangeEventId;
+const crypto_1 = require("crypto");
+const projection_1 = require("../analytics/projection");
+/** SHA-256 the input and format the first 32 hex chars as a UUID. */
+function sha256Uuid(input) {
+    const hex32 = (0, crypto_1.createHash)("sha256").update(input).digest("hex").slice(0, 32);
+    return (0, projection_1.formatHexAsUuid)(hex32);
+}
+function deriveSessionStartEventId(sessionId) {
+    return sha256Uuid(`session_start:${sessionId}`);
+}
+function deriveSessionEndEventId(sessionId) {
+    return sha256Uuid(`session_end:${sessionId}`);
+}
+/**
+ * Activity (turn) ids. `turnIndex` is the analytics-side `turn_index` (1-based,
+ * positional in the transcript). Activity is one-per-user-turn: host_inject
+ * continuation turns are filtered out before we ever derive an id, so there
+ * are no gaps from the import emitter's perspective.
+ */
+function deriveActivityStartEventId(sessionId, turnIndex) {
+    return sha256Uuid(`activity_start:${sessionId}:${turnIndex}`);
+}
+function deriveActivityEndEventId(sessionId, turnIndex) {
+    return sha256Uuid(`activity_end:${sessionId}:${turnIndex}`);
+}
+/**
+/**
+ * Activity-id (the `activity_id` foreign key carried by child events).
+ *
+ * Format: UUID-shaped (8-4-4-4-12) — matches what live mode emits (live
+ * uses `randomUUID()` at the SessionStart hook, baked into `state.json`,
+ * then read by every PreToolUse). Backends that store `activity_id` as a
+ * UUID column accept both live and import values uniformly.
+ *
+ * Determinism: same `(session_id, turn_index, start_time)` tuple always
+ * produces the same UUID, so re-imports collide cleanly. Independent of
+ * `session_turn_analytics.turn_id` (which keeps its 16-char hex form per
+ * analytics spec) — they're separate identifiers for related-but-distinct
+ * concepts (hook-runtime activity vs. analytics-projection turn).
+ */
+function deriveActivityId(sessionId, turnIndex, startTime) {
+    const hex32 = (0, crypto_1.createHash)("sha256").update(`${sessionId}|${turnIndex}|${startTime}`).digest("hex").slice(0, 32);
+    return (0, projection_1.formatHexAsUuid)(hex32);
+}
+/**
+ * Default tool_call event id when `_metadata.toolCallId` is absent (transcript
+ * predates the `_metadata.toolCallId` convention). Falls back to a
+ * deterministic derivation from the host's `tool_use.id`. For transcripts
+ * that DO carry `_metadata.toolCallId`, the import emitter uses that
+ * UUID verbatim instead — collapses cleanly with the live MCP-shipped
+ * event id on the collector.
+ */
+function deriveToolCallEventIdFromToolUseId(sessionId, toolUseId) {
+    return sha256Uuid(`tool_call:${sessionId}:${toolUseId}`);
+}
+function deriveFileChangeEventId(sessionId, toolUseId) {
+    return sha256Uuid(`file_change:${sessionId}:${toolUseId}`);
+}
+//# sourceMappingURL=ids.js.map

package/dist/import/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../src/import/ids.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;AAWH,8DAEC;AAED,0DAEC;AAQD,gEAEC;AAED,4DAEC;AAiBD,4CAGC;AAUD,gFAEC;AAED,0DAEC;AAjED,mCAAoC;AACpC,wDAA0D;AAE1D,qEAAqE;AACrE,SAAS,UAAU,CAAC,KAAa;IAC7B,MAAM,KAAK,GAAW,IAAA,mBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACpF,OAAO,IAAA,4BAAe,EAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,SAAgB,yBAAyB,CAAC,SAAiB;IACvD,OAAO,UAAU,CAAC,iBAAiB,SAAS,EAAE,CAAC,CAAC;AACpD,CAAC;AAED,SAAgB,uBAAuB,CAAC,SAAiB;IACrD,OAAO,UAAU,CAAC,eAAe,SAAS,EAAE,CAAC,CAAC;AAClD,CAAC;AAED;;;;;GAKG;AACH,SAAgB,0BAA0B,CAAC,SAAiB,EAAE,SAAiB;IAC3E,OAAO,UAAU,CAAC,kBAAkB,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAClE,CAAC;AAED,SAAgB,wBAAwB,CAAC,SAAiB,EAAE,SAAiB;IACzE,OAAO,UAAU,CAAC,gBAAgB,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,gBAAgB,CAAC,SAAiB,EAAE,SAAiB,EAAE,SAAiB;IACpF,MAAM,KAAK,GAAW,IAAA,mBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,SAAS,IAAI,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACvH,OAAO,IAAA,4BAAe,EAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kCAAkC,CAAC,SAAiB,EAAE,SAAiB;IACnF,OAAO,UAAU,CAAC,aAAa,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAC7D,CAAC;AAED,SAAgB,uBAAuB,CAAC,SAAiB,EAAE,SAAiB;IACxE,OAAO,UAAU,CAAC,eAAe,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;AAC/D,CAAC"}

package/dist/import/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * IronBee CLI — Import Module Public Barrel
+ *
+ * Exposes ONLY the client-agnostic API. Client-specific modules
+ * (`claude/**`, future `cursor/**`) are NOT re-exported here —
+ * `commands/import.ts` and any other consumer must go through the
+ * generic dispatcher in `pipeline.ts` so adding a new client never
+ * forces a CLI change.
+ *
+ * Public surface:
+ *   - findTranscripts(scope)       — discovery (dispatched per client)
+ *   - estimateImport(opts)         — dry-run estimator (dispatched per client)
+ *   - importSession(opts)          — per-session driver (dispatched per client)
+ *   - applyTimeRange / parseSinceDuration / parseIsoDate / buildTimeRange — generic
+ *   - shouldSkip                   — generic skip rule
+ *   - writeImportMarker / readImportMarker — generic marker file R/W
+ *   - postEvents                   — generic collector POST helper
+ *   - ProgressReporter             — generic progress UI
+ *   - All `Import*` types
+ */
+export { findTranscripts, estimateImport, importSession, ImportSessionOpts, EstimateOpts } from "./pipeline";
+export { runConcurrentPool, ConcurrentPoolOpts } from "./concurrent-pool";
+export { applyTimeRange, parseSinceDuration, parseIsoDate, buildTimeRange } from "./filter";
+export { shouldSkip } from "./skip";
+export { writeImportMarker, readImportMarker, MARKER_SCHEMA_VERSION, markerPath } from "./marker";
+export { postEvents, EmitterOpts } from "./emitter";
+export { ProgressReporter } from "./progress";
+export { ImportEventCounts, ImportMarker, ImportOptions, ImportProjectSummary, ImportResult, ImportScope, ImportSummary, ImportTarget, ImportTimeRange, DerivedEvent, emptyEventCounts, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/import/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/import/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,aAAa,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG7G,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG1E,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAG9C,OAAO,EACH,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,YAAY,EACZ,WAAW,EACX,aAAa,EACb,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,gBAAgB,GACnB,MAAM,SAAS,CAAC"}

package/dist/import/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Public Barrel
+ *
+ * Exposes ONLY the client-agnostic API. Client-specific modules
+ * (`claude/**`, future `cursor/**`) are NOT re-exported here —
+ * `commands/import.ts` and any other consumer must go through the
+ * generic dispatcher in `pipeline.ts` so adding a new client never
+ * forces a CLI change.
+ *
+ * Public surface:
+ *   - findTranscripts(scope)       — discovery (dispatched per client)
+ *   - estimateImport(opts)         — dry-run estimator (dispatched per client)
+ *   - importSession(opts)          — per-session driver (dispatched per client)
+ *   - applyTimeRange / parseSinceDuration / parseIsoDate / buildTimeRange — generic
+ *   - shouldSkip                   — generic skip rule
+ *   - writeImportMarker / readImportMarker — generic marker file R/W
+ *   - postEvents                   — generic collector POST helper
+ *   - ProgressReporter             — generic progress UI
+ *   - All `Import*` types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emptyEventCounts = exports.ProgressReporter = exports.postEvents = exports.markerPath = exports.MARKER_SCHEMA_VERSION = exports.readImportMarker = exports.writeImportMarker = exports.shouldSkip = exports.buildTimeRange = exports.parseIsoDate = exports.parseSinceDuration = exports.applyTimeRange = exports.runConcurrentPool = exports.importSession = exports.estimateImport = exports.findTranscripts = void 0;
+// Generic dispatcher (the one entry point that knows about clients).
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "findTranscripts", { enumerable: true, get: function () { return pipeline_1.findTranscripts; } });
+Object.defineProperty(exports, "estimateImport", { enumerable: true, get: function () { return pipeline_1.estimateImport; } });
+Object.defineProperty(exports, "importSession", { enumerable: true, get: function () { return pipeline_1.importSession; } });
+// Generic bounded-concurrency pool (used by the CLI command, exposed for testability).
+var concurrent_pool_1 = require("./concurrent-pool");
+Object.defineProperty(exports, "runConcurrentPool", { enumerable: true, get: function () { return concurrent_pool_1.runConcurrentPool; } });
+// Generic helpers — no client-specific logic.
+var filter_1 = require("./filter");
+Object.defineProperty(exports, "applyTimeRange", { enumerable: true, get: function () { return filter_1.applyTimeRange; } });
+Object.defineProperty(exports, "parseSinceDuration", { enumerable: true, get: function () { return filter_1.parseSinceDuration; } });
+Object.defineProperty(exports, "parseIsoDate", { enumerable: true, get: function () { return filter_1.parseIsoDate; } });
+Object.defineProperty(exports, "buildTimeRange", { enumerable: true, get: function () { return filter_1.buildTimeRange; } });
+var skip_1 = require("./skip");
+Object.defineProperty(exports, "shouldSkip", { enumerable: true, get: function () { return skip_1.shouldSkip; } });
+var marker_1 = require("./marker");
+Object.defineProperty(exports, "writeImportMarker", { enumerable: true, get: function () { return marker_1.writeImportMarker; } });
+Object.defineProperty(exports, "readImportMarker", { enumerable: true, get: function () { return marker_1.readImportMarker; } });
+Object.defineProperty(exports, "MARKER_SCHEMA_VERSION", { enumerable: true, get: function () { return marker_1.MARKER_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "markerPath", { enumerable: true, get: function () { return marker_1.markerPath; } });
+var emitter_1 = require("./emitter");
+Object.defineProperty(exports, "postEvents", { enumerable: true, get: function () { return emitter_1.postEvents; } });
+var progress_1 = require("./progress");
+Object.defineProperty(exports, "ProgressReporter", { enumerable: true, get: function () { return progress_1.ProgressReporter; } });
+// Types.
+var types_1 = require("./types");
+Object.defineProperty(exports, "emptyEventCounts", { enumerable: true, get: function () { return types_1.emptyEventCounts; } });
+//# sourceMappingURL=index.js.map

package/dist/import/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/import/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAEH,qEAAqE;AACrE,uCAA6G;AAApG,2GAAA,eAAe,OAAA;AAAE,0GAAA,cAAc,OAAA;AAAE,yGAAA,aAAa,OAAA;AAEvD,uFAAuF;AACvF,qDAA0E;AAAjE,oHAAA,iBAAiB,OAAA;AAE1B,8CAA8C;AAC9C,mCAA4F;AAAnF,wGAAA,cAAc,OAAA;AAAE,4GAAA,kBAAkB,OAAA;AAAE,sGAAA,YAAY,OAAA;AAAE,wGAAA,cAAc,OAAA;AACzE,+BAAoC;AAA3B,kGAAA,UAAU,OAAA;AACnB,mCAAkG;AAAzF,2GAAA,iBAAiB,OAAA;AAAE,0GAAA,gBAAgB,OAAA;AAAE,+GAAA,qBAAqB,OAAA;AAAE,oGAAA,UAAU,OAAA;AAC/E,qCAAoD;AAA3C,qGAAA,UAAU,OAAA;AACnB,uCAA8C;AAArC,4GAAA,gBAAgB,OAAA;AAEzB,SAAS;AACT,iCAYiB;AADb,yGAAA,gBAAgB,OAAA"}

package/dist/import/marker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * IronBee CLI — Import Module Marker File
+ *
+ * Written to `<projectDir>/.ironbee/sessions/<session_id>/imported.json`
+ * after every event for the session has been POSTed successfully. Together
+ * with the skip rule, the marker is what makes import idempotent across
+ * re-runs ().
+ *
+ * If `projectDir` does not exist on disk (synthetic projectDir from
+ * undecoded `--all-projects` folder), the marker write is a no-op with a
+ * debug log — re-runs would re-emit, accepted trade-off.
+ */
+import { ImportEventCounts, ImportMarker } from "./types";
+export declare const MARKER_SCHEMA_VERSION: string;
+export declare function markerPath(projectDir: string, sessionId: string): string;
+/** Persist the marker. Returns `false` when the parent project doesn't exist. */
+export declare function writeImportMarker(projectDir: string, sessionId: string, transcriptPath: string, transcriptOffset: number, eventsSent: ImportEventCounts): boolean;
+/** Read an existing marker. Returns `null` when missing or unreadable. */
+export declare function readImportMarker(projectDir: string, sessionId: string): ImportMarker | null;
+//# sourceMappingURL=marker.d.ts.map

package/dist/import/marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker.d.ts","sourceRoot":"","sources":["../../src/import/marker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1D,eAAO,MAAM,qBAAqB,EAAE,MAAc,CAAC;AAEnD,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,iFAAiF;AACjF,wBAAgB,iBAAiB,CAC7B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,iBAAiB,GAC9B,OAAO,CA0BT;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAY3F"}

package/dist/import/marker.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Marker File
+ *
+ * Written to `<projectDir>/.ironbee/sessions/<session_id>/imported.json`
+ * after every event for the session has been POSTed successfully. Together
+ * with the skip rule, the marker is what makes import idempotent across
+ * re-runs ().
+ *
+ * If `projectDir` does not exist on disk (synthetic projectDir from
+ * undecoded `--all-projects` folder), the marker write is a no-op with a
+ * debug log — re-runs would re-emit, accepted trade-off.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MARKER_SCHEMA_VERSION = void 0;
+exports.markerPath = markerPath;
+exports.writeImportMarker = writeImportMarker;
+exports.readImportMarker = readImportMarker;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_1 = require("../lib/logger");
+const gitignore_1 = require("../lib/gitignore");
+exports.MARKER_SCHEMA_VERSION = "1.0";
+function markerPath(projectDir, sessionId) {
+    return (0, path_1.join)(projectDir, ".ironbee", "sessions", sessionId, "imported.json");
+}
+/** Persist the marker. Returns `false` when the parent project doesn't exist. */
+function writeImportMarker(projectDir, sessionId, transcriptPath, transcriptOffset, eventsSent) {
+    if (!(0, fs_1.existsSync)(projectDir)) {
+        logger_1.logger.debug(`import marker: projectDir ${projectDir} does not exist — skipping marker write`);
+        return false;
+    }
+    // Idempotently ensure `.ironbee/sessions/` is gitignored. Operators
+    // who skip `ironbee install` (import-only flows) wouldn't otherwise
+    // get the gitignore entry, and the marker file we're about to write
+    // would surface in `git status`. No-op when already present.
+    (0, gitignore_1.ensureIronBeeGitignored)(projectDir);
+    const target = markerPath(projectDir, sessionId);
+    const marker = {
+        imported_at: new Date().toISOString(),
+        transcript_path: transcriptPath,
+        transcript_offset: transcriptOffset,
+        events_sent: eventsSent,
+        schema_version: exports.MARKER_SCHEMA_VERSION,
+    };
+    try {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(target), { recursive: true });
+        (0, fs_1.writeFileSync)(target, JSON.stringify(marker, null, 2) + "\n");
+        return true;
+    }
+    catch (e) {
+        logger_1.logger.debug(`import marker: write ${target} failed: ${e instanceof Error ? e.message : e}`);
+        return false;
+    }
+}
+/** Read an existing marker. Returns `null` when missing or unreadable. */
+function readImportMarker(projectDir, sessionId) {
+    const target = markerPath(projectDir, sessionId);
+    if (!(0, fs_1.existsSync)(target)) {
+        return null;
+    }
+    try {
+        const text = (0, fs_1.readFileSync)(target, "utf-8");
+        return JSON.parse(text);
+    }
+    catch (e) {
+        logger_1.logger.debug(`import marker: read ${target} failed: ${e instanceof Error ? e.message : e}`);
+        return null;
+    }
+}
+//# sourceMappingURL=marker.js.map

package/dist/import/marker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marker.js","sourceRoot":"","sources":["../../src/import/marker.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAUH,gCAEC;AAGD,8CAgCC;AAGD,4CAYC;AA5DD,2BAAwE;AACxE,+BAAqC;AACrC,0CAAuC;AACvC,gDAA2D;AAG9C,QAAA,qBAAqB,GAAW,KAAK,CAAC;AAEnD,SAAgB,UAAU,CAAC,UAAkB,EAAE,SAAiB;IAC5D,OAAO,IAAA,WAAI,EAAC,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;AAChF,CAAC;AAED,iFAAiF;AACjF,SAAgB,iBAAiB,CAC7B,UAAkB,EAClB,SAAiB,EACjB,cAAsB,EACtB,gBAAwB,EACxB,UAA6B;IAE7B,IAAI,CAAC,IAAA,eAAU,EAAC,UAAU,CAAC,EAAE,CAAC;QAC1B,eAAM,CAAC,KAAK,CAAC,6BAA6B,UAAU,yCAAyC,CAAC,CAAC;QAC/F,OAAO,KAAK,CAAC;IACjB,CAAC;IACD,oEAAoE;IACpE,oEAAoE;IACpE,oEAAoE;IACpE,6DAA6D;IAC7D,IAAA,mCAAuB,EAAC,UAAU,CAAC,CAAC;IACpC,MAAM,MAAM,GAAW,UAAU,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IACzD,MAAM,MAAM,GAAiB;QACzB,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QACrC,eAAe,EAAE,cAAc;QAC/B,iBAAiB,EAAE,gBAAgB;QACnC,WAAW,EAAE,UAAU;QACvB,cAAc,EAAE,6BAAqB;KACxC,CAAC;IACF,IAAI,CAAC;QACD,IAAA,cAAS,EAAC,IAAA,cAAO,EAAC,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAChD,IAAA,kBAAa,EAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAC9D,OAAO,IAAI,CAAC;IAChB,CAAC;IAAC,OAAO,CAAU,EAAE,CAAC;QAClB,eAAM,CAAC,KAAK,CAAC,wBAAwB,MAAM,YAAY,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC7F,OAAO,KAAK,CAAC;IACjB,CAAC;AACL,CAAC;AAED,0EAA0E;AAC1E,SAAgB,gBAAgB,CAAC,UAAkB,EAAE,SAAiB;IAClE,MAAM,MAAM,GAAW,UAAU,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IACzD,IAAI,CAAC,IAAA,eAAU,EAAC,MAAM,CAAC,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,IAAI,CAAC;QACD,MAAM,IAAI,GAAW,IAAA,iBAAY,EAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAiB,CAAC;IAC5C,CAAC;IAAC,OAAO,CAAU,EAAE,CAAC;QAClB,eAAM,CAAC,KAAK,CAAC,uBAAuB,MAAM,YAAY,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC5F,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC"}

package/dist/import/pipeline.d.ts

@@ -0,0 +1,41 @@
+/**
+ * IronBee CLI — Import Module Generic Pipeline Dispatcher
+ *
+ * The single point that knows about client-specific runners. v1 only
+ * ships Claude; when Cursor support lands, every function here gains a
+ * branch on `scope.client` (or per-target discriminator) that dispatches
+ * to `cursor/{discovery,summary,runner}` — but no other file in the
+ * import tree changes. This is the contract that lets `commands/import.ts`
+ * stay client-agnostic.
+ *
+ * Isolation principle: Claude/Cursor logic stays separated
+ * by file. The CLI command depends on this dispatcher, NOT on any
+ * `claude/*` module directly.
+ */
+import { ImportResult, ImportScope, ImportSummary, ImportTarget, ImportTimeRange } from "./types";
+export interface ImportSessionOpts {
+    target: ImportTarget;
+    force: boolean;
+    /** Events per collector POST; null = use target/default. */
+    batchSize?: number | null;
+}
+export interface EstimateOpts {
+    targets: ImportTarget[];
+    timeRange: ImportTimeRange | null;
+    concurrency: number;
+    force: boolean;
+}
+/**
+ * Discover candidate transcripts on disk. v1 always routes through Claude;
+ * when Cursor lands, this branches on `scope` (or a separate `--client`
+ * flag) and dispatches to `cursor/discovery`.
+ */
+export declare function findTranscripts(scope: ImportScope): ImportTarget[];
+/**
+ * Pre-pass estimate for the dry-run summary. Same dispatch shape as
+ * `findTranscripts` — currently Claude-only.
+ */
+export declare function estimateImport(opts: EstimateOpts): ImportSummary;
+/** Per-session entry point. */
+export declare function importSession(opts: ImportSessionOpts): Promise<ImportResult>;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/import/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/import/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAKlG,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,YAAY;IACzB,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,SAAS,EAAE,eAAe,GAAG,IAAI,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,EAAE,CAElE;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,YAAY,GAAG,aAAa,CAOhE;AAED,+BAA+B;AAC/B,wBAAsB,aAAa,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAElF"}

package/dist/import/pipeline.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * IronBee CLI — Import Module Generic Pipeline Dispatcher
+ *
+ * The single point that knows about client-specific runners. v1 only
+ * ships Claude; when Cursor support lands, every function here gains a
+ * branch on `scope.client` (or per-target discriminator) that dispatches
+ * to `cursor/{discovery,summary,runner}` — but no other file in the
+ * import tree changes. This is the contract that lets `commands/import.ts`
+ * stay client-agnostic.
+ *
+ * Isolation principle: Claude/Cursor logic stays separated
+ * by file. The CLI command depends on this dispatcher, NOT on any
+ * `claude/*` module directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findTranscripts = findTranscripts;
+exports.estimateImport = estimateImport;
+exports.importSession = importSession;
+const discovery_1 = require("./claude/discovery");
+const summary_1 = require("./claude/summary");
+const runner_1 = require("./claude/runner");
+/**
+ * Discover candidate transcripts on disk. v1 always routes through Claude;
+ * when Cursor lands, this branches on `scope` (or a separate `--client`
+ * flag) and dispatches to `cursor/discovery`.
+ */
+function findTranscripts(scope) {
+    return (0, discovery_1.findClaudeTranscripts)(scope);
+}
+/**
+ * Pre-pass estimate for the dry-run summary. Same dispatch shape as
+ * `findTranscripts` — currently Claude-only.
+ */
+function estimateImport(opts) {
+    return (0, summary_1.estimateClaudeImport)({
+        targets: opts.targets,
+        timeRange: opts.timeRange,
+        concurrency: opts.concurrency,
+        force: opts.force,
+    });
+}
+/** Per-session entry point. */
+async function importSession(opts) {
+    return (0, runner_1.importClaudeSession)({ target: opts.target, force: opts.force, batchSize: opts.batchSize ?? null });
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/import/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../src/import/pipeline.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;AA0BH,0CAEC;AAMD,wCAOC;AAGD,sCAEC;AA3CD,kDAA6E;AAC7E,8CAAwD;AACxD,4CAAsD;AAgBtD;;;;GAIG;AACH,SAAgB,eAAe,CAAC,KAAkB;IAC9C,OAAO,IAAA,iCAAc,EAAC,KAAK,CAAC,CAAC;AACjC,CAAC;AAED;;;GAGG;AACH,SAAgB,cAAc,CAAC,IAAkB;IAC7C,OAAO,IAAA,8BAAoB,EAAC;QACxB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,KAAK,EAAE,IAAI,CAAC,KAAK;KACpB,CAAC,CAAC;AACP,CAAC;AAED,+BAA+B;AACxB,KAAK,UAAU,aAAa,CAAC,IAAuB;IACvD,OAAO,IAAA,4BAAmB,EAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,IAAI,EAAE,CAAC,CAAC;AAC9G,CAAC"}

package/dist/import/progress.d.ts

@@ -0,0 +1,20 @@
+/**
+ * IronBee CLI — Import Module Progress Reporter
+ *
+ * Thin stdout-write helper for per-session progress lines + final summary.
+ * Stays out of `pipeline.ts` so the pipeline core is free of formatting
+ * concerns and easy to unit-test.
+ */
+import { ImportResult } from "./types";
+export declare class ProgressReporter {
+    private importedCount;
+    private skippedCount;
+    private failedCount;
+    private startedAtMs;
+    private totalSessions;
+    constructor(totalSessions: number);
+    onSessionStart(sessionId: string, idx: number): void;
+    onSessionComplete(result: ImportResult, idx: number): void;
+    finalSummary(): void;
+}
+//# sourceMappingURL=progress.d.ts.map

package/dist/import/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/import/progress.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,qBAAa,gBAAgB;IACzB,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,WAAW,CAAsB;IACzC,OAAO,CAAC,aAAa,CAAa;gBAEtB,aAAa,EAAE,MAAM;IAIjC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAKpD,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAgB1D,YAAY,IAAI,IAAI;CAavB"}