lunel-cli 0.1.115 → 0.1.117

package/dist/ai/codex.d.ts

@@ -13,6 +13,8 @@ export declare class CodexProvider implements AIProvider {
     private pendingQuestionRequestIds;
     private assistantMessageIdByTurnId;
     private partTextById;
+    private debugLog;
+    private debugHistory;
     init(): Promise<void>;
     destroy(): Promise<void>;
     subscribe(emitter: AiEventEmitter): () => void;
@@ -87,6 +89,7 @@ export declare class CodexProvider implements AIProvider {
     private resolveSessionFromPayload;
     private resolveInFlightTurnId;
     private decodeMessagesFromThreadRead;
+    private logThreadReadSummary;
     private decodeStoredToolLikePart;
     private describeStoredToolName;
     private extractStoredToolInput;

package/dist/ai/codex.js

@@ -51,6 +51,17 @@ export class CodexProvider {
     pendingQuestionRequestIds = new Map();
     assistantMessageIdByTurnId = new Map();
     partTextById = new Map();
+    debugLog(message, fields) {
+        if (!DEBUG_MODE)
+            return;
+        const suffix = fields ? ` ${JSON.stringify(fields)}` : "";
+        console.log(`[codex] ${message}${suffix}`);
+    }
+    debugHistory(message, fields) {
+        if (!DEBUG_MODE)
+            return;
+        console.log(`[codex-history] ${message} ${JSON.stringify(fields)}`);
+    }
     async init() {
         if (DEBUG_MODE)
             console.log("Starting Codex app-server...");
@@ -100,7 +111,10 @@ export class CodexProvider {
         };
     }
     async createSession(title) {
-        const result = await this.call("thread/start", { cwd: process.cwd() });
+        const result = await this.call("thread/start", {
+            cwd: process.cwd(),
+            persistExtendedHistory: true,
+        });
         const threadObject = this.extractThreadObject(result);
         const threadId = this.extractThreadId(threadObject);
         if (!threadId) {
@@ -207,6 +221,11 @@ export class CodexProvider {
     }
     async getMessages(sessionId) {
         const session = this.ensureLocalSession(sessionId);
+        this.debugLog("getMessages start", {
+            sessionId,
+            existingMessageCount: session.messages.length,
+            existingPartCount: session.messages.reduce((sum, message) => sum + (message.parts?.length || 0), 0),
+        });
         const result = await this.call("thread/read", {
             threadId: session.id,
             includeTurns: true,
@@ -215,7 +234,16 @@ export class CodexProvider {
         if (!threadObject) {
             return { messages: session.messages };
         }
+        this.logThreadReadSummary(sessionId, threadObject);
         const historyMessages = this.decodeMessagesFromThreadRead(sessionId, threadObject);
+        this.debugLog("getMessages decoded thread", {
+            sessionId,
+            turnCount: this.readArray(threadObject.turns).length,
+            decodedMessageCount: historyMessages.length,
+            decodedPartCount: historyMessages.reduce((sum, message) => sum + (message.parts?.length || 0), 0),
+            decodedRoles: historyMessages.map((message) => message.role),
+            decodedPartTypes: historyMessages.flatMap((message) => (message.parts || []).map((part) => String(this.asRecord(part).type ?? "unknown"))),
+        });
         if (historyMessages.length > 0) {
             session.messages = historyMessages;
         }
@@ -1107,7 +1135,10 @@ export class CodexProvider {
                 return;
         }
         const session = this.sessions.get(threadId);
-        const params = { threadId };
+        const params = {
+            threadId,
+            persistExtendedHistory: true,
+        };
         if (session?.cwd) {
             params.cwd = session.cwd;
         }
@@ -1174,9 +1205,11 @@ export class CodexProvider {
             const assistantParts = [];
             let assistantMessageId;
             let assistantTimestamp = turnTime;
+            const turnItemTypes = [];
             for (const item of items) {
                 const itemObject = this.asRecord(item);
                 const type = this.normalizedItemType(this.readString(itemObject.type) ?? "");
+                turnItemTypes.push(type || "unknown");
                 const itemId = this.readString(itemObject.id) ?? crypto.randomUUID();
                 const timestamp = this.extractUpdatedAt(itemObject) ?? this.extractCreatedAt(itemObject) ?? (turnTime + orderOffset++);
                 if (type === "usermessage") {
@@ -1239,6 +1272,7 @@ export class CodexProvider {
                     || type === "mcptoolcall"
                     || type === "dynamictoolcall"
                     || type === "collabtoolcall"
+                    || type === "collabagenttoolcall"
                     || type === "websearch"
                     || type === "imageview") {
                     assistantMessageId = assistantMessageId ?? (turnId ? `assistant:${turnId}` : itemId);
@@ -1268,9 +1302,53 @@ export class CodexProvider {
                     this.assistantMessageIdByTurnId.set(turnId, resolvedAssistantMessageId);
                 }
             }
+            this.debugLog("decoded stored turn", {
+                threadId,
+                turnId: turnId ?? null,
+                itemCount: items.length,
+                itemTypes: turnItemTypes,
+                emittedUserMessages: messages.filter((message) => message.role === "user").length,
+                emittedAssistantParts: assistantParts.length,
+            });
         }
         return messages;
     }
+    logThreadReadSummary(sessionId, threadObject) {
+        const turns = this.readArray(threadObject.turns);
+        const turnSummaries = turns.map((turn, index) => {
+            const turnObject = this.asRecord(turn);
+            const items = this.readArray(turnObject.items);
+            return {
+                index,
+                turnId: this.readString(turnObject.id) ?? null,
+                status: this.readString(turnObject.status) ?? this.readString(this.asRecord(turnObject.status).type) ?? null,
+                itemCount: items.length,
+                itemTypes: items.map((item) => this.normalizedItemType(this.readString(this.asRecord(item).type) ?? "") || "unknown"),
+                itemSummaries: items.map((item) => {
+                    const itemObject = this.asRecord(item);
+                    const type = this.normalizedItemType(this.readString(itemObject.type) ?? "") || "unknown";
+                    return {
+                        id: this.readString(itemObject.id) ?? null,
+                        type,
+                        keys: Object.keys(itemObject).sort(),
+                        textPreview: this.firstString(itemObject, ["text", "summary", "message", "query", "path", "tool", "command"])?.slice(0, 120) ?? null,
+                        hasAggregatedOutput: typeof itemObject.aggregatedOutput === "string" && itemObject.aggregatedOutput.length > 0,
+                        aggregatedOutputLength: typeof itemObject.aggregatedOutput === "string" ? itemObject.aggregatedOutput.length : 0,
+                        changesCount: Array.isArray(itemObject.changes) ? itemObject.changes.length : 0,
+                        hasResult: itemObject.result != null,
+                        hasContentItems: Array.isArray(itemObject.contentItems) && itemObject.contentItems.length > 0,
+                        status: this.readString(itemObject.status) ?? null,
+                    };
+                }),
+            };
+        });
+        this.debugHistory("thread/read summary", {
+            sessionId,
+            threadId: this.readString(threadObject.id) ?? null,
+            turnCount: turns.length,
+            turnSummaries,
+        });
+    }
     decodeStoredToolLikePart(type, itemObject, threadId, messageId, itemId) {
         if (type === "filechange" || type === "diff" || this.isFileChangeStructuredItem(type, itemObject)) {
             const output = this.decodeFileLikeItemText(itemObject) ?? this.describeCompletedItemOutput(itemObject, itemObject, type) ?? "File changes";
@@ -1312,6 +1390,9 @@ export class CodexProvider {
         if (type === "imageview") {
             return "image-view";
         }
+        if (type === "collabtoolcall" || type === "collabagenttoolcall") {
+            return "agent";
+        }
         if (type === "enteredreviewmode") {
             return "review";
         }

package/dist/ai/opencode.d.ts

@@ -8,6 +8,9 @@ export declare class OpenCodeProvider implements AIProvider {
     private emitter;
     private knownPendingPermissionIds;
     private knownPendingQuestionIds;
+    private debugLog;
+    private debugWarn;
+    private debugError;
     init(): Promise<void>;
     destroy(): Promise<void>;
     subscribe(emitter: AiEventEmitter): () => void;

package/dist/ai/opencode.js

@@ -262,6 +262,21 @@ export class OpenCodeProvider {
     emitter = null;
     knownPendingPermissionIds = new Set();
     knownPendingQuestionIds = new Set();
+    debugLog(message, ...args) {
+        if (!VERBOSE_AI_LOGS)
+            return;
+        console.log(message, ...args);
+    }
+    debugWarn(message, ...args) {
+        if (!VERBOSE_AI_LOGS)
+            return;
+        console.warn(message, ...args);
+    }
+    debugError(message, ...args) {
+        if (!VERBOSE_AI_LOGS)
+            return;
+        console.error(message, ...args);
+    }
     async init() {
         const opencodeUsername = "lunel";
         const opencodePassword = crypto.randomBytes(32).toString("base64url");
@@ -521,13 +536,13 @@ export class OpenCodeProvider {
                         path: { id: this.lastActiveSessionId },
                     });
                     if (checkResp.error) {
-                        console.warn(`[sse] OpenCode session ${this.lastActiveSessionId} was garbage-collected. Notifying app.`);
+                        this.debugWarn(`[sse] OpenCode session ${this.lastActiveSessionId} was garbage-collected. Notifying app.`);
                         const gcSessionId = this.lastActiveSessionId;
                         this.lastActiveSessionId = null;
                         this.emitter?.({ type: "session_gc", properties: { sessionId: gcSessionId } });
                     }
                     else {
-                        console.log(`[sse] Active session ${this.lastActiveSessionId} still valid.`);
+                        this.debugLog(`[sse] Active session ${this.lastActiveSessionId} still valid.`);
                     }
                 }
                 if (attempt > 0) {
@@ -535,7 +550,7 @@ export class OpenCodeProvider {
                 }
                 const events = await this.client.event.subscribe();
                 if (attempt > 0) {
-                    console.log(`[sse] reconnected after ${attempt} attempt(s)`);
+                    this.debugLog(`[sse] reconnected after ${attempt} attempt(s)`);
                 }
                 attempt = 0;
                 for await (const raw of events.stream) {
@@ -549,11 +564,11 @@ export class OpenCodeProvider {
                         ? parsed.payload
                         : parsed;
                     if (!base || typeof base.type !== "string") {
-                        console.warn("[sse] Dropped malformed event:", redactSensitive(JSON.stringify(parsed).substring(0, 200)));
+                        this.debugWarn("[sse] Dropped malformed event:", redactSensitive(JSON.stringify(parsed).substring(0, 200)));
                         continue;
                     }
                     if (base.type !== "server.heartbeat") {
-                        console.log("[sse]", base.type);
+                        this.debugLog("[sse]", base.type);
                     }
                     const normalizedEvent = normalizeOpenCodeEvent({
                         type: base.type,
@@ -562,7 +577,7 @@ export class OpenCodeProvider {
                     this.trackPermissionEvent(normalizedEvent.type, normalizedEvent.properties || {});
                     this.emitter?.(normalizedEvent);
                 }
-                console.log("[sse] Event stream ended, reconnecting...");
+                this.debugLog("[sse] Event stream ended, reconnecting...");
                 attempt++;
             }
             catch (err) {
@@ -570,9 +585,9 @@ export class OpenCodeProvider {
                     return;
                 attempt++;
                 const delay = backoffMs(attempt - 1);
-                console.error(`[sse] Stream error (attempt ${attempt}/${SSE_MAX_RETRIES}): ${err.message}. Retrying in ${delay}ms`);
+                this.debugError(`[sse] Stream error (attempt ${attempt}/${SSE_MAX_RETRIES}): ${err.message}. Retrying in ${delay}ms`);
                 if (attempt >= SSE_MAX_RETRIES) {
-                    console.error("[sse] Max retries reached. Sending error event to app and giving up.");
+                    this.debugError("[sse] Max retries reached. Sending error event to app and giving up.");
                     this.emitter?.({
                         type: "sse_dead",
                         properties: { error: err.message, attempts: attempt },
@@ -668,10 +683,10 @@ export class OpenCodeProvider {
                         });
                     }
                 }
-                console.log(`[sse] Re-synced messages for busy session ${sessionId} after reconnect`);
+                this.debugLog(`[sse] Re-synced messages for busy session ${sessionId} after reconnect`);
             }
             catch (err) {
-                console.warn(`[sse] Failed to refresh messages for busy session ${sessionId}:`, err.message);
+                this.debugWarn(`[sse] Failed to refresh messages for busy session ${sessionId}:`, err.message);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.115",
+  "version": "0.1.117",
   "author": [
     {
       "name": "Soham Bharambe",