lazy-gravity 0.9.1 → 0.10.0

package/dist/handlers/__tests__/fileChangeButtonAction.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileChangeButtonAction_1 = require("../fileChangeButtonAction");
+describe('fileChangeButtonAction', () => {
+    let mockInteraction;
+    let mockCdp;
+    let mockBridge;
+    let mockWsHandler;
+    beforeEach(() => {
+        mockInteraction = {
+            deferUpdate: jest.fn().mockResolvedValue(undefined),
+            reply: jest.fn().mockResolvedValue(undefined),
+            update: jest.fn().mockResolvedValue(undefined),
+            followUp: jest.fn().mockResolvedValue(undefined),
+        };
+        mockCdp = {
+            isConnected: jest.fn().mockReturnValue(true),
+            call: jest.fn(),
+        };
+        mockBridge = {
+            lastActiveWorkspace: 'test_project',
+            pool: {
+                getConnected: jest.fn().mockReturnValue(mockCdp),
+                extractProjectName: jest.fn().mockReturnValue('test_project'),
+            },
+        };
+        mockWsHandler = {
+            getWorkspaceForChannel: jest.fn().mockReturnValue('test_project'),
+        };
+    });
+    it('matches valid legacy custom IDs', () => {
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        expect(action.match('ide_file_accept_all')).toEqual({ action: 'accept', projectName: '', channelId: '' });
+        expect(action.match('ide_file_reject_all')).toEqual({ action: 'reject', projectName: '', channelId: '' });
+        expect(action.match('unknown_button')).toBeNull();
+    });
+    it('matches valid custom IDs with project and channel', () => {
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        expect(action.match('file_change_accept:proj:chan1')).toEqual({ action: 'accept', projectName: 'proj', channelId: 'chan1' });
+        expect(action.match('file_change_reject:proj:chan2')).toEqual({ action: 'reject', projectName: 'proj', channelId: 'chan2' });
+    });
+    it('fails if linked to a different session channel', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept', channelId: 'channel_456' });
+        expect(mockInteraction.reply).toHaveBeenCalledWith({ text: 'This file change action is linked to a different session channel.' });
+    });
+    it('fails if not connected to IDE', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.isConnected.mockReturnValue(false);
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept', channelId: 'channel_123' });
+        expect(mockInteraction.reply).toHaveBeenCalledWith({ text: 'Not connected to IDE.' });
+    });
+    it('successfully accepts changes when button is found', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.call.mockResolvedValue({ result: { value: true } });
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept' });
+        expect(mockCdp.call).toHaveBeenCalled();
+        expect(mockInteraction.update).toHaveBeenCalledWith({
+            text: '✅ Accepted file changes.',
+            components: [],
+        });
+    });
+    it('successfully rejects changes when button is found', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.call.mockResolvedValue({ result: { value: true } });
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'reject' });
+        expect(mockInteraction.update).toHaveBeenCalledWith({
+            text: '❌ Rejected file changes.',
+            components: [],
+        });
+    });
+    it('sends followup if button is not found', async () => {
+        mockInteraction.channel = { id: 'channel_123' };
+        mockCdp.call.mockResolvedValue({ result: { value: false } });
+        const action = (0, fileChangeButtonAction_1.createFileChangeButtonAction)({ bridge: mockBridge, wsHandler: mockWsHandler });
+        await action.execute(mockInteraction, { action: 'accept' });
+        expect(mockInteraction.followUp).toHaveBeenCalledWith({
+            text: expect.stringContaining('Could not find the "Accept all" button'),
+        });
+    });
+});

package/dist/handlers/approvalButtonAction.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createApprovalButtonAction = createApprovalButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
 function createApprovalButtonAction(deps) {
     return {
@@ -32,7 +33,7 @@ function createApprovalButtonAction(deps) {
                     .catch(() => { });
                 return;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             logger_1.logger.debug(`[ApprovalAction] action=${action} project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
             const detector = projectName
                 ? deps.bridge.pool.getApprovalDetector(projectName)

package/dist/handlers/errorPopupButtonAction.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createErrorPopupButtonAction = createErrorPopupButtonAction;
+const projectResolver_1 = require("../utils/projectResolver");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const logger_1 = require("../utils/logger");
 const MAX_DEBUG_CONTENT = 4096;
@@ -30,7 +31,7 @@ function createErrorPopupButtonAction(deps) {
                     .catch(() => { });
                 return;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             const detector = projectName
                 ? deps.bridge.pool.getErrorPopupDetector(projectName)
                 : undefined;

package/dist/handlers/fileChangeButtonAction.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileChangeButtonAction = createFileChangeButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const projectResolver_1 = require("../utils/projectResolver");
+const logger_1 = require("../utils/logger");
+const approvalDetector_1 = require("../services/approvalDetector");
+function createFileChangeButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, cdpBridgeManager_1.parseFileChangeCustomId)(customId);
+            if (!parsed)
+                return null;
+            return {
+                action: parsed.action,
+                projectName: parsed.projectName ?? '',
+                channelId: parsed.channelId ?? '',
+            };
+        },
+        async execute(interaction, params) {
+            const { action, channelId } = params;
+            // Acknowledge immediately so Telegram/Discord doesn't time out
+            await interaction.deferUpdate().catch(() => { });
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This file change action is linked to a different session channel.' })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
+            const cdp = projectName ? deps.bridge.pool.getConnected(projectName) : undefined;
+            if (!cdp || !cdp.isConnected()) {
+                await interaction
+                    .reply({ text: 'Not connected to IDE.' })
+                    .catch(() => { });
+                return;
+            }
+            const targetText = action === 'accept' ? 'Accept all' : 'Reject all';
+            try {
+                const result = await cdp.call('Runtime.evaluate', {
+                    expression: (0, approvalDetector_1.buildClickScript)(targetText),
+                    returnByValue: true,
+                    awaitPromise: true,
+                });
+                if (result?.result?.value?.ok) {
+                    await interaction
+                        .update({
+                        text: `${action === 'accept' ? '✅ Accepted' : '❌ Rejected'} file changes.`,
+                        components: [],
+                    })
+                        .catch((err) => {
+                        logger_1.logger.warn('[FileChangeAction] update failed:', err);
+                    });
+                }
+                else {
+                    await interaction
+                        .followUp({ text: `Could not find the "${targetText}" button in the IDE. The file change prompt may have been dismissed.` })
+                        .catch(() => { });
+                }
+            }
+            catch (error) {
+                logger_1.logger.error('[FileChangeAction] Error clicking button:', error);
+                await interaction
+                    .followUp({ text: 'An error occurred while interacting with the IDE.' })
+                    .catch(() => { });
+            }
+        },
+    };
+}

package/dist/handlers/genericActionButtonAction.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGenericActionCustomId = parseGenericActionCustomId;
+exports.createGenericActionButtonAction = createGenericActionButtonAction;
+const logger_1 = require("../utils/logger");
+const projectResolver_1 = require("../utils/projectResolver");
+const approvalDetector_1 = require("../services/approvalDetector");
+/**
+ * Parses a generic action button customId into its components.
+ * Format: action_btn_[action_name]:[project_name]:[channel_id]
+ *
+ * @param customId The customId to parse
+ * @returns Parsed action details, or null if not an action button
+ */
+function parseGenericActionCustomId(customId) {
+    if (!customId.startsWith('action_btn_'))
+        return null;
+    const parts = customId.split(':');
+    const actionName = parts[0].replace('action_btn_', '').replace(/_/g, ' ');
+    // Capitalize first letter
+    const formattedName = actionName.charAt(0).toUpperCase() + actionName.slice(1);
+    return {
+        actionName: formattedName,
+        projectName: parts[1] || undefined,
+        channelId: parts[2] || undefined,
+    };
+}
+function createGenericActionButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = parseGenericActionCustomId(customId);
+            if (!parsed)
+                return null;
+            const result = { actionName: parsed.actionName };
+            if (parsed.projectName)
+                result.projectName = parsed.projectName;
+            if (parsed.channelId)
+                result.channelId = parsed.channelId;
+            return result;
+        },
+        async execute(interaction, params) {
+            const actionName = params.actionName;
+            const channelId = params.channelId || interaction.channel?.id;
+            if (!channelId) {
+                return;
+            }
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, channelId, params.projectName);
+            await interaction.deferUpdate().catch(() => { });
+            const cdp = projectName
+                ? deps.bridge.pool.getConnected(projectName)
+                : null;
+            if (!cdp) {
+                await interaction.followUp({
+                    text: 'Not connected to Antigravity. Send the action as a message instead.',
+                }).catch(() => { });
+                return;
+            }
+            // Simulate DOM click instead of chat injection
+            logger_1.logger.info(`[GenericActionButton] Clicking action button "${actionName}" via DOM script`);
+            const script = (0, approvalDetector_1.buildClickScript)(actionName);
+            const evalResult = await cdp.call('Runtime.evaluate', {
+                expression: script,
+                returnByValue: true,
+            });
+            const resultValue = evalResult.result?.value;
+            if (!resultValue?.ok) {
+                await interaction.followUp({
+                    text: `Failed to execute action: Button "${actionName}" not found or obscured.`,
+                }).catch(() => { });
+                return;
+            }
+        },
+    };
+}

package/dist/handlers/planningButtonAction.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPlanningButtonAction = createPlanningButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
 const MAX_PLAN_CONTENT = 4096;
 function createPlanningButtonAction(deps) {
@@ -32,7 +33,7 @@ function createPlanningButtonAction(deps) {
                     .catch(() => { });
                 return;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             const detector = projectName
                 ? deps.bridge.pool.getPlanningDetector(projectName)
                 : undefined;
@@ -43,15 +44,18 @@ function createPlanningButtonAction(deps) {
                 return;
             }
             if (action === 'open') {
-                const clicked = await detector.clickOpenButton();
-                if (!clicked) {
-                    await interaction
-                        .reply({ text: 'Open button not found.' })
-                        .catch(() => { });
-                    return;
+                let clicked = false;
+                if (detector.getLastDetectedInfo()?.hasOpenButton) {
+                    try {
+                        clicked = await detector.clickOpenButton();
+                        if (clicked) {
+                            await new Promise((resolve) => setTimeout(resolve, 500));
+                        }
+                    }
+                    catch (e) {
+                        logger_1.logger.error('[PlanningAction] clickOpenButton failed:', e);
+                    }
                 }
-                // Wait for DOM to update after Open click
-                await new Promise((resolve) => setTimeout(resolve, 500));
                 // Extract plan content with retry
                 let planContent = null;
                 for (let attempt = 0; attempt < 3; attempt++) {
@@ -60,6 +64,12 @@ function createPlanningButtonAction(deps) {
                         break;
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
+                if (!planContent && !clicked) {
+                    await interaction
+                        .reply({ text: 'Plan content could not be extracted from the IDE.' })
+                        .catch(() => { });
+                    return;
+                }
                 await interaction
                     .update({
                     text: '📋 Plan opened',
@@ -84,6 +94,11 @@ function createPlanningButtonAction(deps) {
                         .catch(() => { });
                 }
             }
+            else if (action === 'reject') {
+                // Reject action
+                await interaction.reply({ text: 'Rejection of the plan is not allowed.' }).catch(() => { });
+                return;
+            }
             else {
                 // Proceed action
                 await interaction.deferUpdate().catch(() => { });

package/dist/handlers/questionSelectAction.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQuestionSelectAction = createQuestionSelectAction;
+const logger_1 = require("../utils/logger");
+const notificationSender_1 = require("../services/notificationSender");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
+const projectResolver_1 = require("../utils/projectResolver");
+function createQuestionSelectAction(deps) {
+    return {
+        match(customId) {
+            return customId.startsWith(notificationSender_1.QUESTION_SELECT_ACTION_PREFIX);
+        },
+        async execute(interaction, values) {
+            const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(interaction.customId, notificationSender_1.QUESTION_SELECT_ACTION_PREFIX);
+            if (!parsed)
+                return;
+            const selectedOption = parseInt(values[0], 10);
+            if (isNaN(selectedOption))
+                return;
+            const channelId = parsed.channelId;
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This question is linked to a different session channel.', ephemeral: true })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, parsed.projectName);
+            logger_1.logger.debug(`[QuestionSelectAction] project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
+            const detector = projectName
+                ? deps.bridge.pool.getQuestionDetector(projectName)
+                : undefined;
+            if (!detector) {
+                logger_1.logger.warn(`[QuestionSelectAction] No detector for project=${projectName}`);
+                await interaction
+                    .reply({ text: 'Question detector not found.', ephemeral: true })
+                    .catch(() => { });
+                return;
+            }
+            await interaction.deferUpdate().catch(() => { });
+            let success = false;
+            try {
+                success = await detector.submitOption(selectedOption);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger_1.logger.error(`[QuestionSelectAction] CDP click failed: ${msg}`);
+                await interaction
+                    .followUp({ text: `Failed to answer question: ${msg}`, ephemeral: true })
+                    .catch(() => { });
+                return;
+            }
+            if (success) {
+                const updatePayload = { text: `✅ Submitted option ${selectedOption + 1}`, components: [] };
+                try {
+                    await interaction.editReply(updatePayload);
+                }
+                catch (editErr) {
+                    logger_1.logger.warn('[QuestionSelectAction] editReply failed, sending followUp:', editErr);
+                    await interaction.followUp({ text: `✅ Submitted option ${selectedOption + 1}` }).catch(() => { });
+                }
+            }
+            else {
+                await interaction
+                    .followUp({ text: 'Failed to answer question (it may have been resolved already).', ephemeral: true })
+                    .catch(() => { });
+            }
+        },
+    };
+}

package/dist/handlers/questionSkipAction.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQuestionSkipAction = createQuestionSkipAction;
+const logger_1 = require("../utils/logger");
+const notificationSender_1 = require("../services/notificationSender");
+const questionActionUtils_1 = require("../utils/questionActionUtils");
+const projectResolver_1 = require("../utils/projectResolver");
+function createQuestionSkipAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(customId, notificationSender_1.QUESTION_SKIP_ACTION_PREFIX);
+            return parsed ? { action: parsed.action } : null;
+        },
+        async execute(interaction, params) {
+            const parsed = (0, questionActionUtils_1.parseQuestionCustomId)(interaction.customId, notificationSender_1.QUESTION_SKIP_ACTION_PREFIX);
+            if (!parsed)
+                return;
+            const channelId = parsed.channelId;
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This question is linked to a different session channel.', ephemeral: true })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, parsed.projectName);
+            logger_1.logger.debug(`[QuestionSkipAction] project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
+            const detector = projectName
+                ? deps.bridge.pool.getQuestionDetector(projectName)
+                : undefined;
+            if (!detector) {
+                logger_1.logger.warn(`[QuestionSkipAction] No detector for project=${projectName}`);
+                await interaction
+                    .reply({ text: 'Question detector not found.', ephemeral: true })
+                    .catch(() => { });
+                return;
+            }
+            await interaction.deferUpdate().catch(() => { });
+            let success = false;
+            try {
+                success = await detector.skipQuestion();
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger_1.logger.error(`[QuestionSkipAction] CDP click failed: ${msg}`);
+                await interaction
+                    .followUp({ text: `Failed to skip question: ${msg}`, ephemeral: true })
+                    .catch(() => { });
+                return;
+            }
+            if (success) {
+                const updatePayload = { text: `✅ Skipped question`, components: [] };
+                try {
+                    await interaction.editReply(updatePayload);
+                }
+                catch (editErr) {
+                    logger_1.logger.warn('[QuestionSkipAction] editReply failed, sending followUp:', editErr);
+                    await interaction.followUp({ text: `✅ Skipped question` }).catch(() => { });
+                }
+            }
+            else {
+                await interaction
+                    .followUp({ text: 'Failed to skip question (it may have been resolved already).', ephemeral: true })
+                    .catch(() => { });
+            }
+        },
+    };
+}

package/dist/handlers/runCommandButtonAction.js

@@ -8,6 +8,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRunCommandButtonAction = createRunCommandButtonAction;
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const projectResolver_1 = require("../utils/projectResolver");
 const logger_1 = require("../utils/logger");
 function createRunCommandButtonAction(deps) {
     return {
@@ -31,7 +32,7 @@ function createRunCommandButtonAction(deps) {
                     .catch(() => { });
                 return;
             }
-            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const projectName = (0, projectResolver_1.resolveProjectName)(deps, interaction.channel.id, params.projectName);
             const detector = projectName
                 ? deps.bridge.pool.getRunCommandDetector(projectName)
                 : undefined;

package/dist/platform/discord/discordResponseRenderer.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDiscordResponse = renderDiscordResponse;
+const discord_js_1 = require("discord.js");
+/**
+ * Splits a long string into chunks that fit within Discord's embed description limit (4096 chars).
+ * Tries to split on double newlines, then single newlines, then spaces, before hard splitting.
+ */
+function chunkText(text, limit = 4000) {
+    if (!text)
+        return [];
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= limit) {
+            chunks.push(remaining);
+            break;
+        }
+        let slice = remaining.slice(0, limit);
+        let splitIndex = slice.lastIndexOf('\n\n');
+        if (splitIndex === -1 || splitIndex < limit * 0.5) {
+            splitIndex = slice.lastIndexOf('\n');
+        }
+        if (splitIndex === -1 || splitIndex < limit * 0.5) {
+            splitIndex = slice.lastIndexOf(' ');
+        }
+        if (splitIndex === -1 || splitIndex < limit * 0.5) {
+            splitIndex = limit; // Hard split
+        }
+        chunks.push(remaining.slice(0, splitIndex).trim());
+        remaining = remaining.slice(splitIndex).trim();
+    }
+    return chunks;
+}
+/**
+ * Renders a classified Antigravity response into a Discord Message payload.
+ *
+ * Handles chunking for large outputs and structured cards (plan, files, actions).
+ */
+function renderDiscordResponse(result, options) {
+    const embeds = [];
+    const components = [];
+    // 1. Final Output Text
+    if (result.finalOutputText) {
+        const textChunks = chunkText(result.finalOutputText, 4000); // leave some buffer
+        for (let i = 0; i < textChunks.length && i < 8; i++) { // max 10 embeds total, leave room
+            const embed = new discord_js_1.EmbedBuilder()
+                .setColor(0x2b2d31) // Discord dark mode background-ish / neutral
+                .setDescription(textChunks[i]);
+            embeds.push(embed);
+        }
+    }
+    // 2. Plan Cards
+    if (result.planCards && result.planCards.length > 0) {
+        const planText = result.planCards.join('\n\n');
+        const chunks = chunkText(planText, 4000);
+        for (let i = 0; i < chunks.length && embeds.length < 10; i++) {
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle(i === 0 ? 'Plan' : null)
+                .setColor(0x5865f2) // Blurple
+                .setDescription(chunks[i]);
+            embeds.push(embed);
+        }
+    }
+    // 3. File Changes
+    if (result.fileChanges && result.fileChanges.length > 0) {
+        const embed = new discord_js_1.EmbedBuilder()
+            .setTitle('File Changes')
+            .setColor(0x3ba55c); // Greenish
+        // Chunk into fields if necessary (max 25 fields, 1024 chars per field)
+        let currentFieldVal = '';
+        let fieldCount = 0;
+        let processedCount = 0;
+        let truncated = false;
+        for (const file of result.fileChanges) {
+            if (fieldCount >= 24) {
+                truncated = true;
+                break;
+            }
+            const line = `- \`${file.path}\` (${file.type})\n`;
+            if (line.length > 1000) {
+                if (currentFieldVal) {
+                    embed.addFields({ name: fieldCount === 0 ? 'Files' : '...', value: currentFieldVal });
+                    currentFieldVal = '';
+                    fieldCount++;
+                }
+                const splitLine = chunkText(line, 1000);
+                for (const sl of splitLine) {
+                    if (fieldCount >= 24) {
+                        truncated = true;
+                        break;
+                    }
+                    embed.addFields({ name: fieldCount === 0 ? 'Files' : '...', value: sl || '-' });
+                    fieldCount++;
+                }
+            }
+            else if (currentFieldVal.length + line.length > 1000) {
+                if (currentFieldVal) {
+                    embed.addFields({ name: fieldCount === 0 ? 'Files' : '...', value: currentFieldVal });
+                    fieldCount++;
+                }
+                currentFieldVal = line;
+            }
+            else {
+                currentFieldVal += line;
+            }
+            if (!truncated) {
+                processedCount++;
+            }
+        }
+        if (currentFieldVal && fieldCount < 24) {
+            embed.addFields({ name: fieldCount === 0 ? 'Files' : '...', value: currentFieldVal });
+            fieldCount++;
+        }
+        if (processedCount < result.fileChanges.length) {
+            const remaining = result.fileChanges.length - processedCount;
+            embed.addFields({ name: '...', value: `*...and ${remaining} more*` });
+        }
+        embeds.push(embed);
+    }
+    // 4. Action Buttons
+    if (result.actionButtons && result.actionButtons.length > 0) {
+        const row = new discord_js_1.ActionRowBuilder();
+        for (let i = 0; i < result.actionButtons.length && i < 5; i++) { // Max 5 buttons per row
+            const btnText = result.actionButtons[i];
+            let customId = `action_btn_${btnText.toLowerCase().replace(/\s+/g, '_')}`;
+            if (options?.projectName && options?.channelId) {
+                const overhead = customId.length + 2 + options.channelId.length;
+                const safeProject = options.projectName.length > (100 - overhead)
+                    ? options.projectName.substring(0, 100 - overhead)
+                    : options.projectName;
+                customId = `${customId}:${safeProject}:${options.channelId}`;
+            }
+            const btn = new discord_js_1.ButtonBuilder()
+                .setCustomId(customId)
+                .setLabel(btnText)
+                .setStyle(btnText.toLowerCase() === 'proceed' || btnText.toLowerCase() === 'open'
+                ? discord_js_1.ButtonStyle.Primary
+                : discord_js_1.ButtonStyle.Secondary);
+            row.addComponents(btn);
+        }
+        components.push(row);
+    }
+    // 5. Fallback if absolutely empty
+    if (embeds.length === 0) {
+        if (result.activityLines && result.activityLines.length > 0) {
+            const embed = new discord_js_1.EmbedBuilder()
+                .setColor(0x2b2d31)
+                .setDescription('*(Processing...)*\n' + result.activityLines.slice(-3).join('\n').slice(0, 3900));
+            embeds.push(embed);
+        }
+        else {
+            return { content: '*(No output)*' };
+        }
+    }
+    // Discord allows max 10 embeds per message.
+    const finalEmbeds = embeds.slice(0, 10);
+    return {
+        embeds: finalEmbeds,
+        components: components.length > 0 ? components : undefined,
+    };
+}