@ekkos/cli 0.2.7 → 0.2.8

package/dist/cache/types.d.ts

@@ -55,13 +55,20 @@ export interface SessionMeta {
     project_path?: string;
     created_at: string;
 }
+/**
+ * Open loop detected during stream restore (incomplete tool, etc.)
+ */
+export interface OpenLoop {
+    type: string;
+    detail: string;
+}
 /**
  * Restore payload returned by RestoreOrchestrator
  */
 export interface RestorePayload {
     session_id: string;
     session_name: string;
-    source: 'local' | 'redis' | 'supabase';
+    source: 'local' | 'redis' | 'supabase' | 'stream';
     restored_turns: Turn[];
     latest: {
         user_query: string;
@@ -80,6 +87,8 @@ export interface RestorePayload {
         token_estimate: number;
         complete_turn_count: number;
         has_pending: boolean;
+        is_stream_restore?: boolean;
+        open_loops?: OpenLoop[];
     };
 }
 /**
@@ -121,7 +130,7 @@ export interface CacheResult<T> {
     success: boolean;
     data?: T;
     error?: string;
-    source?: 'local' | 'redis' | 'supabase';
+    source?: 'local' | 'redis' | 'supabase' | 'stream';
     latency_ms?: number;
 }
 /**

package/dist/capture/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stream capture module for ekkOS
+ *
+ * Provides real-time capture of Claude Code transcripts for
+ * near-zero context loss on /continue.
+ */
+export * from './types';
+export * from './stream-tailer';

package/dist/capture/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Stream capture module for ekkOS
+ *
+ * Provides real-time capture of Claude Code transcripts for
+ * near-zero context loss on /continue.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./stream-tailer"), exports);

package/dist/capture/stream-tailer.d.ts

@@ -0,0 +1,138 @@
+/**
+ * JSONL Stream Tailer for Claude Code transcripts
+ *
+ * Tails ~/.claude/projects/{encoded-path}/{session-uuid}.jsonl
+ * and extracts assistant_stream + tool events in real-time.
+ *
+ * This is the core component for "near-zero context loss" on /continue.
+ */
+import { EventEmitter } from 'events';
+import { TailerState, StreamEvent, TurnStatus } from './types';
+export interface StreamTailerOptions {
+    transcriptPath: string;
+    sessionId: string;
+    sessionName?: string;
+    cacheDir: string;
+    onEvent?: (event: StreamEvent) => void;
+}
+export declare class StreamTailer extends EventEmitter {
+    private state;
+    private cacheDir;
+    private eventLogPath;
+    private stateMachinePath;
+    private checkpointPath;
+    private pollTimer;
+    private checkpointTimer;
+    private running;
+    private onEventCallback?;
+    private eventCounter;
+    private stateMachine;
+    private inProgressText;
+    private eventsSinceCheckpoint;
+    private seenEventIds;
+    /**
+     * Generate a stable event_id for idempotency
+     *
+     * CRITICAL: event_id must be stable for the same underlying transcript data.
+     * Using transcript_line_uuid + block_index ensures:
+     * - Same ID after tailer restart
+     * - De-dupe when reading overlapping transcript ranges
+     * - True idempotency for append operations
+     *
+     * Format: {kind_prefix}_{transcript_line_uuid}_{block_index}_{content_hash}
+     */
+    private generateEventId;
+    /**
+     * Generate content hash for delta events
+     */
+    private hashContent;
+    /**
+     * Initialize state machine with default values
+     */
+    private initStateMachine;
+    /**
+     * Update state machine state
+     */
+    private updateState;
+    /**
+     * Update in-progress text head/tail
+     */
+    private updateInProgressText;
+    /**
+     * Clear in-progress text (on turn seal)
+     */
+    private clearInProgressText;
+    /**
+     * Add open loop
+     */
+    private addOpenLoop;
+    /**
+     * Close open loop
+     */
+    private closeOpenLoop;
+    /**
+     * Save state machine to disk
+     */
+    private saveStateMachine;
+    /**
+     * Save checkpoint
+     */
+    private saveCheckpoint;
+    constructor(options: StreamTailerOptions);
+    /**
+     * Start tailing the transcript file
+     */
+    start(): Promise<void>;
+    /**
+     * Stop tailing
+     */
+    stop(): void;
+    /**
+     * Get current state (for debugging/status)
+     */
+    getState(): Readonly<TailerState>;
+    private schedulePoll;
+    private poll;
+    private readNewContent;
+    private processBuffer;
+    private processLine;
+    private handleUserEvent;
+    private handleAssistantEvent;
+    private emitEvent;
+}
+/**
+ * Utility: Reconstruct StreamTurn from event log
+ */
+export declare function reconstructTurnFromEvents(eventLogPath: string, turnId?: number): Promise<{
+    turns: Map<number, {
+        user_query: string;
+        assistant_stream: string;
+        tools: Array<{
+            kind: string;
+            id: string;
+            name?: string;
+            ts: string;
+        }>;
+        status: TurnStatus;
+    }>;
+    latestTurnId: number;
+}>;
+/**
+ * Utility: Middle-truncate text (keep head + tail)
+ */
+export declare function middleTruncate(text: string, opts?: {
+    headChars?: number;
+    tailChars?: number;
+    maxTotal?: number;
+}): string;
+/**
+ * Utility: Detect open loops (incomplete tools)
+ */
+export declare function detectOpenLoops(tools: Array<{
+    kind: string;
+    id: string;
+    ts: string;
+}>): Array<{
+    type: string;
+    detail: string;
+}>;