@gkorepanov/ccodex 0.4.14 → 0.4.16

package/dist/claude/session/session.js

@@ -27,6 +27,7 @@ import { StaleClaudeRuntimeSettingsError, createProviderRuntime, providerPermiss
 import { isRetryableClaudeRuntimeStartupError, } from "./providerRuntime.js";
 import { assistantHasTools, backgroundOutputFile, backgroundTaskId, isNoQueryAcknowledgement, serverToolResult, toolResults, } from "./providerFacts.js";
 import { normalizeClaudeModelIdentifier } from "../modelSelection.js";
+import { StreamingFileChangePreview } from "../streamingFilePreview.js";
 const nullSource = { providerEventId: null, providerEventType: null };
 const providerJournalMaxEvents = 20_000;
 const providerJournalMaxBytes = 256 * 1_024 * 1_024;
@@ -100,7 +101,7 @@ function commandLane(command) {
         return "control";
     if (["providerEventStarted", "providerEventFinished", "providerBoundary", "providerRetract",
         "conversationReset", "modelFallback", "fastModeStatus", "systemNotice", "runtimeNotification", "mainStream",
-        "accountUsage", "accountCost", "publishUsage", "lifecycle", "compactBoundary", "compactFailed",
+        "accountUsage", "accountCost", "publishUsage", "lifecycle", "autoCompactStarted", "compactBoundary", "compactFailed",
         "postCompact",
     ].includes(command.type))
         return "provider";
@@ -134,6 +135,7 @@ export class ClaudeSession {
     scopes = new Map();
     tasks = new Map();
     compaction;
+    automaticCompaction;
     compactionActions = [];
     lastPublishedUsage;
     lifecycle;
@@ -594,6 +596,7 @@ export class ClaudeSession {
         const projection = {
             context: new AsyncLocalStorage(),
             processEpoch: uuidv7(),
+            filePreviews: new Map(),
             providerSequence: 0,
         };
         try {
@@ -1340,6 +1343,13 @@ export class ClaudeSession {
             if (status === "requesting") {
                 await this.providerSubmitLifecycle(projection, runtimeGeneration, { type: "request", messageStarted: false });
             }
+            else if (status === "compacting") {
+                await this.submitProviderProjection(runtimeGeneration, {
+                    type: "autoCompactStarted",
+                    runtimeGeneration,
+                    source: this.providerFactSource(projection),
+                });
+            }
             return "stateOnly";
         }
         if (message.type === "system" && message.subtype === "session_state_changed") {
@@ -1762,6 +1772,37 @@ export class ClaudeSession {
             fact,
         });
     }
+    async applyProviderToolInput(projection, runtimeGeneration, index, delta, ownerThreadId = this.threadId) {
+        const projected = await this.applyProviderMainStream(projection, runtimeGeneration, {
+            kind: "toolInput", index, delta,
+        }, ownerThreadId);
+        const tool = projected?.tool;
+        if (tool?.name !== "Write" && tool?.name !== "Edit")
+            return;
+        const key = `${ownerThreadId}\0${index}`;
+        let state = projection.filePreviews.get(key);
+        if (!state) {
+            state = { providerId: tool.providerId, preview: new StreamingFileChangePreview(tool.name, tool.cwd) };
+            projection.filePreviews.set(key, state);
+        }
+        const change = await state.preview.push(delta);
+        if (change)
+            await this.applyProviderMainStream(projection, runtimeGeneration, {
+                kind: "toolFiles", providerId: state.providerId, changes: [change],
+            }, ownerThreadId);
+    }
+    async finishProviderToolInput(projection, runtimeGeneration, index, ownerThreadId = this.threadId) {
+        const key = `${ownerThreadId}\0${index}`;
+        const state = projection.filePreviews.get(key);
+        if (!state)
+            return;
+        projection.filePreviews.delete(key);
+        const change = await state.preview.finish();
+        if (change)
+            await this.applyProviderMainStream(projection, runtimeGeneration, {
+                kind: "toolFiles", providerId: state.providerId, changes: [change],
+            }, ownerThreadId);
+    }
     async canUseProviderTool(projection, runtimeGeneration, name, input, options) {
         const context = await this.providerCallbackContext(runtimeGeneration);
         if (!context)
@@ -2183,15 +2224,12 @@ export class ClaudeSession {
                 }, childThreadId);
             }
             else if (event.delta.type === "input_json_delta") {
-                await this.applyProviderMainStream(projection, runtimeGeneration, {
-                    kind: "toolInput",
-                    index: event.index,
-                    delta: event.delta.partial_json,
-                }, childThreadId);
+                await this.applyProviderToolInput(projection, runtimeGeneration, event.index, event.delta.partial_json, childThreadId);
             }
             return;
         }
         if (event.type === "content_block_stop") {
+            await this.finishProviderToolInput(projection, runtimeGeneration, event.index, childThreadId);
             await this.applyProviderMainStream(projection, runtimeGeneration, { kind: "blockStop", index: event.index }, childThreadId);
         }
     }
@@ -2510,15 +2548,12 @@ export class ClaudeSession {
                 });
             }
             else if (event.delta.type === "input_json_delta") {
-                await this.applyProviderMainStream(projection, runtimeGeneration, {
-                    kind: "toolInput",
-                    index: event.index,
-                    delta: event.delta.partial_json,
-                });
+                await this.applyProviderToolInput(projection, runtimeGeneration, event.index, event.delta.partial_json);
             }
             return;
         }
         if (event.type === "content_block_stop") {
+            await this.finishProviderToolInput(projection, runtimeGeneration, event.index);
             await this.applyProviderMainStream(projection, runtimeGeneration, { kind: "blockStop", index: event.index });
         }
     }
@@ -4472,10 +4507,15 @@ export class ClaudeSession {
                 if (command.runtimeGeneration !== this.runtimeGeneration)
                     return { admitted: false, hidden: false };
                 return {
-                    admitted: command.trigger === "auto" ? !this.compaction && Boolean(this.activeNormalTurn())
+                    admitted: command.trigger === "auto"
+                        ? !this.compaction && Boolean(this.automaticCompaction || this.activeNormalTurn())
                         : Boolean(this.compaction && !this.compaction.cancellation),
                     hidden: Boolean(this.compaction?.hidden),
                 };
+            case "autoCompactStarted":
+                if (command.runtimeGeneration !== this.runtimeGeneration)
+                    return undefined;
+                return this.startAutomaticCompaction(command.runtimeGeneration, command.source);
             case "compactBoundary":
                 if (command.runtimeGeneration !== this.runtimeGeneration)
                     return undefined;
@@ -4501,8 +4541,10 @@ export class ClaudeSession {
                     : this.compactionProjection();
             }
             case "compactFailed":
-                if (command.runtimeGeneration !== this.runtimeGeneration || !this.compaction)
+                if (command.runtimeGeneration !== this.runtimeGeneration)
                     return undefined;
+                if (!this.compaction)
+                    return this.completeAutomaticCompaction(command.source);
                 if (this.compaction.cancellation)
                     return this.compactionProjection();
                 return this.completeCompaction("failed", command.message, command.codexErrorInfo, command.source);
@@ -4842,21 +4884,77 @@ export class ClaudeSession {
         if (this.compaction)
             return this.compactionProjection();
         const record = this.requireRecord(true);
-        const turn = this.activeNormalTurn(record);
+        const automatic = this.automaticCompaction;
+        const turn = automatic
+            ? this.repository.readTurn(this.threadId, automatic.turnId)
+            : this.activeNormalTurn(record);
         if (!turn)
             return undefined;
+        const item = automatic
+            ? turn.items.find((candidate) => candidate.id === automatic.itemId)
+            : undefined;
         const updated = { ...record, lastClaudeMessageUuid: boundary };
-        this.commitState(updated, [{
+        this.commitState(updated, [
+            ...(item?.type === "contextCompaction" ? [{
+                    turnId: turn.id,
+                    method: "item/completed",
+                    params: { item, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() },
+                    providerEventId: source.providerEventId,
+                    providerEventType: source.providerEventType,
+                }] : []),
+            {
                 turnId: turn.id,
                 method: "thread/compacted",
                 params: { threadId: this.threadId, turnId: turn.id },
                 providerEventId: source.providerEventId,
                 providerEventType: source.providerEventType,
-            }], turn, false, {
+            },
+        ], turn, false, {
             ownerThreadId: this.threadId,
             turnId: turn.id,
             messageUuid: boundary,
         });
+        if (automatic)
+            this.automaticCompaction = undefined;
+        return { turnId: turn.id, terminal: false };
+    }
+    startAutomaticCompaction(runtimeGeneration, source) {
+        if (this.compaction)
+            return this.compactionProjection();
+        const turn = this.activeNormalTurn();
+        if (!turn)
+            return undefined;
+        if (this.automaticCompaction?.turnId === turn.id) {
+            return { turnId: turn.id, terminal: false };
+        }
+        const item = {
+            type: "contextCompaction",
+            id: uuidv7(),
+        };
+        turn.items.push(item);
+        this.publishTurn(turn, "item/started", {
+            item, threadId: this.threadId, turnId: turn.id, startedAtMs: Date.now(),
+        }, source);
+        this.automaticCompaction = { turnId: turn.id, itemId: item.id, runtimeGeneration };
+        return { turnId: turn.id, terminal: false };
+    }
+    completeAutomaticCompaction(source) {
+        const automatic = this.automaticCompaction;
+        if (!automatic)
+            return undefined;
+        const record = this.requireRecord(false);
+        const turn = this.repository.readTurn(this.threadId, automatic.turnId);
+        const item = turn?.items.find((candidate) => candidate.id === automatic.itemId);
+        if (!turn || item?.type !== "contextCompaction")
+            return undefined;
+        this.commitState(record, [{
+                turnId: turn.id,
+                method: "item/completed",
+                params: { item, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() },
+                providerEventId: source.providerEventId,
+                providerEventType: source.providerEventType,
+            }], turn);
+        this.automaticCompaction = undefined;
         return { turnId: turn.id, terminal: false };
     }
     completeCompaction(status, errorMessage, codexErrorInfo, source, boundary) {
@@ -4906,7 +5004,7 @@ export class ClaudeSession {
     }
     activeNormalTurn(record = this.requireRecord(true)) {
         return record.thread.turns.findLast((turn) => turn.status === "inProgress"
-            && !turn.items.some((item) => item.type === "contextCompaction"));
+            && turn.items.some((item) => item.type !== "contextCompaction"));
     }
     startTurn(items, threadPatch = {}, id = uuidv7(), emitEvents = true) {
         const record = this.requireRecord(false);
@@ -5076,7 +5174,21 @@ export class ClaudeSession {
                 updatedAt: turn.completedAt, recencyAt: turn.completedAt,
             },
         };
-        const events = [...terminalEvents.map((event) => ({
+        const automatic = this.automaticCompaction?.turnId === turn.id
+            ? this.automaticCompaction
+            : undefined;
+        const automaticItem = automatic
+            ? turn.items.find((item) => item.id === automatic.itemId)
+            : undefined;
+        const events = [
+            ...(automaticItem?.type === "contextCompaction" ? [{
+                    turnId: turn.id,
+                    method: "item/completed",
+                    params: { item: automaticItem, threadId: this.threadId, turnId: turn.id, completedAtMs: Date.now() },
+                    providerEventId: source.providerEventId,
+                    providerEventType: source.providerEventType,
+                }] : []),
+            ...terminalEvents.map((event) => ({
                 ...event,
                 providerEventId: event.providerEventId ?? source.providerEventId,
                 providerEventType: event.providerEventType ?? source.providerEventType,
@@ -5086,7 +5198,8 @@ export class ClaudeSession {
                 params: { threadId: this.threadId, status: updated.thread.status },
                 providerEventId: source.providerEventId,
                 providerEventType: source.providerEventType,
-            }];
+            }
+        ];
         if (turn.error && emitError)
             events.push({
                 turnId: turn.id,
@@ -5105,6 +5218,8 @@ export class ClaudeSession {
             providerEventType: source.providerEventType,
         });
         this.commitState(updated, events, turn, false, providerBoundary, emitEvents);
+        if (automatic)
+            this.automaticCompaction = undefined;
         return { record: updated, turn };
     }
     goalContext() {