lazy-gravity 0.9.2 → 0.11.0

package/dist/handlers/questionSelectAction.js

@@ -0,0 +1,70 @@
+"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 false;
+            const selectedOption = parseInt(values[0], 10);
+            if (isNaN(selectedOption))
+                return false;
+            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 false;
+            }
+            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 false;
+            }
+            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 false;
+            }
+            if (success) {
+                const updatePayload = { text: `✅ Submitted option ${selectedOption + 1}.\n\n⏳ IDE is working on the response...`, 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}.\n\n⏳ IDE is working on the response...` }).catch(() => { });
+                }
+            }
+            else {
+                await interaction
+                    .followUp({ text: 'Failed to answer question (it may have been resolved already).', ephemeral: true })
+                    .catch(() => { });
+            }
+            return success;
+        },
+    };
+}

package/dist/handlers/questionSkipAction.js

@@ -0,0 +1,68 @@
+"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 false;
+            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 false;
+            }
+            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 false;
+            }
+            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 false;
+            }
+            if (success) {
+                const updatePayload = { text: '✅ Skipped question.\n\n⏳ IDE is working on the response...', components: [] };
+                try {
+                    await interaction.editReply(updatePayload);
+                }
+                catch (editErr) {
+                    logger_1.logger.warn('[QuestionSkipAction] editReply failed, sending followUp:', editErr);
+                    await interaction.followUp({ text: '✅ Skipped question.\n\n⏳ IDE is working on the response...' }).catch(() => { });
+                }
+            }
+            else {
+                await interaction
+                    .followUp({ text: 'Failed to skip question (it may have been resolved already).', ephemeral: true })
+                    .catch(() => { });
+            }
+            return success;
+        },
+    };
+}

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,
+    };
+}

package/dist/platform/discord/wrappers.js

@@ -15,6 +15,7 @@ exports.wrapDiscordMessage = wrapDiscordMessage;
 exports.wrapDiscordButton = wrapDiscordButton;
 exports.wrapDiscordSelect = wrapDiscordSelect;
 exports.wrapDiscordCommand = wrapDiscordCommand;
+exports.wrapDiscordModalSubmit = wrapDiscordModalSubmit;
 const discord_js_1 = require("discord.js");
 // ---------------------------------------------------------------------------
 // Style mapping
@@ -107,6 +108,32 @@ function toDiscordComponents(rows) {
         return actionRow;
     });
 }
+/**
+ * Convert a platform ModalDef to a discord.js ModalBuilder.
+ */
+function toDiscordModal(modal) {
+    const builder = new discord_js_1.ModalBuilder()
+        .setCustomId(modal.customId)
+        .setTitle(modal.title);
+    for (const row of modal.components) {
+        const actionRow = new discord_js_1.ActionRowBuilder();
+        for (const comp of row.components) {
+            const input = new discord_js_1.TextInputBuilder()
+                .setCustomId(comp.customId)
+                .setLabel(comp.label)
+                .setStyle(comp.style === 'paragraph' ? discord_js_1.TextInputStyle.Paragraph : discord_js_1.TextInputStyle.Short);
+            if (comp.placeholder !== undefined) {
+                input.setPlaceholder(comp.placeholder);
+            }
+            if (comp.required !== undefined) {
+                input.setRequired(comp.required);
+            }
+            actionRow.addComponents(input);
+        }
+        builder.addComponents(actionRow);
+    }
+    return builder;
+}
 /**
  * Convert a platform MessagePayload to discord.js message send/reply options.
  *
@@ -256,6 +283,9 @@ function wrapDiscordButton(interaction) {
             const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
             return wrapDiscordSentMessage(sent);
         },
+        async showModal(modal) {
+            await interaction.showModal(toDiscordModal(modal));
+        },
     };
 }
 /** Wrap a discord.js StringSelectMenuInteraction as a PlatformSelectInteraction. */
@@ -329,3 +359,49 @@ function wrapDiscordCommand(interaction) {
         },
     };
 }
+/** Wrap a discord.js ModalSubmitInteraction as a PlatformModalSubmitInteraction. */
+function wrapDiscordModalSubmit(interaction) {
+    const user = wrapDiscordUser(interaction.user);
+    const channel = interaction.channel
+        ? wrapDiscordChannel(interaction.channel)
+        : buildFallbackChannel(interaction.channelId ?? 'unknown');
+    const fields = new Map();
+    for (const [key, field] of interaction.fields.fields.entries()) {
+        fields.set(key, interaction.fields.getTextInputValue(key));
+    }
+    return {
+        id: interaction.id,
+        platform: 'discord',
+        customId: interaction.customId,
+        user,
+        channel,
+        messageId: interaction.message?.id ?? null,
+        fields,
+        async deferUpdate() {
+            if (interaction.isFromMessage()) {
+                await interaction.deferUpdate();
+            }
+            else {
+                await interaction.deferReply({ ephemeral: true });
+            }
+        },
+        async reply(payload) {
+            await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async update(payload) {
+            if (interaction.isFromMessage()) {
+                await interaction.update(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            }
+            else {
+                await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            }
+        },
+        async editReply(payload) {
+            await interaction.editReply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async followUp(payload) {
+            const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}