lazy-gravity 0.2.0 → 0.3.0

package/dist/handlers/modeSelectAction.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * Platform-agnostic SelectAction for mode_select interactions.
+ *
+ * When a user selects a mode from the inline dropdown, this action:
+ *   1. Updates the ModeService
+ *   2. Syncs the mode change to Antigravity via CDP
+ *   3. Refreshes the mode selection UI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModeSelectAction = createModeSelectAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const modeService_1 = require("../services/modeService");
+const modeUi_1 = require("../ui/modeUi");
+const logger_1 = require("../utils/logger");
+function createModeSelectAction(deps) {
+    return {
+        match(customId) {
+            return customId === 'mode_select';
+        },
+        async execute(interaction, values) {
+            const selectedMode = values[0];
+            if (!selectedMode)
+                return;
+            // Validate mode name before any side effects
+            const normalized = selectedMode.trim().toLowerCase();
+            if (!['fast', 'plan'].includes(normalized)) {
+                await interaction.followUp({ text: `Invalid mode: ${selectedMode}` }).catch(() => { });
+                return;
+            }
+            await interaction.deferUpdate();
+            // CDP-first: try to sync to Antigravity immediately
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(deps.bridge);
+            const displayName = modeService_1.MODE_DISPLAY_NAMES[selectedMode] || selectedMode;
+            if (cdp) {
+                const res = await cdp.setUiMode(selectedMode);
+                if (!res.ok) {
+                    logger_1.logger.warn(`[ModeSelect] UI mode switch failed: ${res.error}`);
+                    await interaction.followUp({
+                        text: `Failed to switch mode in Antigravity: ${res.error}`,
+                    }).catch(() => { });
+                    return;
+                }
+                // CDP sync succeeded — update local cache as synced
+                deps.modeService.setMode(selectedMode, true);
+                const payload = (0, modeUi_1.buildModePayload)(deps.modeService.getCurrentMode());
+                await interaction.update(payload);
+                await interaction.followUp({
+                    text: `Mode changed to ${displayName}.`,
+                }).catch(() => { });
+            }
+            else {
+                // No CDP — set locally as pending
+                deps.modeService.setMode(selectedMode, false);
+                const payload = (0, modeUi_1.buildModePayload)(deps.modeService.getCurrentMode(), true);
+                await interaction.update(payload);
+                await interaction.followUp({
+                    text: `Mode set to ${displayName}. Will sync when connected to Antigravity.`,
+                }).catch(() => { });
+            }
+        },
+    };
+}

package/dist/handlers/modelButtonAction.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Platform-agnostic ButtonAction for model selection interactions.
+ *
+ * Handles:
+ *   model_btn_<name>  — Switch to the specified model
+ *   model_refresh_btn — Refresh the model list UI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModelButtonAction = createModelButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const modelsUi_1 = require("../ui/modelsUi");
+const logger_1 = require("../utils/logger");
+function createModelButtonAction(deps) {
+    return {
+        match(customId) {
+            if (customId === 'model_refresh_btn') {
+                return { action: 'refresh' };
+            }
+            if (customId === 'model_set_default_btn') {
+                return { action: 'set_default' };
+            }
+            if (customId === 'model_clear_default_btn') {
+                return { action: 'clear_default' };
+            }
+            if (customId.startsWith('model_btn_')) {
+                return { action: 'select', modelName: customId.slice('model_btn_'.length) };
+            }
+            return null;
+        },
+        async execute(interaction, params) {
+            await interaction.deferUpdate();
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(deps.bridge);
+            if (!cdp) {
+                await interaction.followUp({ text: 'Not connected to CDP.' }).catch(() => { });
+                return;
+            }
+            if (params.action === 'set_default') {
+                const currentModel = await cdp.getCurrentModel();
+                if (!currentModel) {
+                    await interaction.followUp({ text: 'No current model detected.' }).catch(() => { });
+                    return;
+                }
+                if (deps.modelService) {
+                    deps.modelService.setDefaultModel(currentModel);
+                }
+                if (deps.userPrefRepo) {
+                    deps.userPrefRepo.setDefaultModel(interaction.user.id, currentModel);
+                }
+                await refreshModelsUI(cdp, deps, interaction);
+                await interaction.followUp({
+                    text: `Default model set to ${currentModel}.`,
+                }).catch(() => { });
+            }
+            else if (params.action === 'clear_default') {
+                if (deps.modelService) {
+                    deps.modelService.setDefaultModel(null);
+                }
+                if (deps.userPrefRepo) {
+                    deps.userPrefRepo.setDefaultModel(interaction.user.id, null);
+                }
+                await refreshModelsUI(cdp, deps, interaction);
+                await interaction.followUp({
+                    text: 'Default model cleared.',
+                }).catch(() => { });
+            }
+            else if (params.action === 'select') {
+                const res = await cdp.setUiModel(params.modelName);
+                if (!res.ok) {
+                    await interaction.followUp({
+                        text: res.error || 'Failed to change model.',
+                    }).catch(() => { });
+                    return;
+                }
+                // Refresh UI after model change
+                await refreshModelsUI(cdp, deps, interaction);
+                await interaction.followUp({
+                    text: `Model changed to ${res.model}.`,
+                }).catch(() => { });
+            }
+            else {
+                // refresh
+                await refreshModelsUI(cdp, deps, interaction);
+            }
+        },
+    };
+}
+async function refreshModelsUI(cdp, actionDeps, interaction) {
+    try {
+        const models = await cdp.getUiModels();
+        const currentModel = await cdp.getCurrentModel();
+        const quotaData = await actionDeps.fetchQuota();
+        const defaultModel = actionDeps.modelService?.getDefaultModel() ?? null;
+        const payload = (0, modelsUi_1.buildModelsPayload)(models, currentModel, quotaData, defaultModel);
+        if (payload) {
+            await interaction.update(payload);
+        }
+    }
+    catch (err) {
+        logger_1.logger.warn('[ModelButton] Failed to refresh models UI:', err?.message || err);
+    }
+}

package/dist/handlers/planningButtonAction.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Platform-agnostic planning button action.
+ *
+ * Handles Open / Proceed button presses for the planning mode dialog
+ * from both Discord and Telegram using the ButtonAction interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlanningButtonAction = createPlanningButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const logger_1 = require("../utils/logger");
+const MAX_PLAN_CONTENT = 4096;
+function createPlanningButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, cdpBridgeManager_1.parsePlanningCustomId)(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 doesn't time out
+            await interaction.deferUpdate().catch(() => { });
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This planning action is linked to a different session channel.' })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const detector = projectName
+                ? deps.bridge.pool.getPlanningDetector(projectName)
+                : undefined;
+            if (!detector) {
+                await interaction
+                    .reply({ text: 'Planning detector not found.' })
+                    .catch(() => { });
+                return;
+            }
+            if (action === 'open') {
+                const clicked = await detector.clickOpenButton();
+                if (!clicked) {
+                    await interaction
+                        .reply({ text: 'Open button not found.' })
+                        .catch(() => { });
+                    return;
+                }
+                // 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++) {
+                    planContent = await detector.extractPlanContent();
+                    if (planContent)
+                        break;
+                    await new Promise((resolve) => setTimeout(resolve, 500));
+                }
+                await interaction
+                    .update({
+                    text: '📋 Plan opened',
+                    components: [],
+                })
+                    .catch((err) => {
+                    logger_1.logger.warn('[PlanningAction] update failed:', err);
+                });
+                if (planContent) {
+                    const truncated = planContent.length > MAX_PLAN_CONTENT
+                        ? planContent.substring(0, MAX_PLAN_CONTENT - 15) + '\n\n(truncated)'
+                        : planContent;
+                    await interaction
+                        .followUp({ text: truncated })
+                        .catch((err) => {
+                        logger_1.logger.warn('[PlanningAction] followUp failed:', err);
+                    });
+                }
+                else {
+                    await interaction
+                        .followUp({ text: 'Could not extract plan content from the editor.' })
+                        .catch(() => { });
+                }
+            }
+            else {
+                // Proceed action
+                await interaction.deferUpdate().catch(() => { });
+                let clicked = false;
+                try {
+                    clicked = await detector.clickProceedButton();
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger_1.logger.error(`[PlanningAction] CDP click failed: ${msg}`);
+                    await interaction.reply({ text: `Proceed failed: ${msg}` }).catch(() => { });
+                    return;
+                }
+                if (clicked) {
+                    await interaction
+                        .update({
+                        text: '▶️ Proceed started',
+                        components: [],
+                    })
+                        .catch((err) => {
+                        logger_1.logger.warn('[PlanningAction] update failed:', err);
+                    });
+                }
+                else {
+                    await interaction
+                        .reply({ text: 'Proceed button not found.' })
+                        .catch(() => { });
+                }
+            }
+        },
+    };
+}

package/dist/handlers/selectHandler.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Platform-agnostic select menu interaction handler.
+ *
+ * Uses a registry pattern similar to buttonHandler: each select type
+ * registers a match+execute pair.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlatformSelectHandler = createPlatformSelectHandler;
+const logger_1 = require("../utils/logger");
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a platform-agnostic select menu handler.
+ * Returns an async function that processes PlatformSelectInteraction events.
+ */
+function createPlatformSelectHandler(deps) {
+    return async (interaction) => {
+        for (const action of deps.actions) {
+            try {
+                if (!action.match(interaction.customId))
+                    continue;
+                await action.execute(interaction, interaction.values);
+                return;
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                logger_1.logger.error('[SelectHandler] Action error:', errorMessage);
+                await interaction
+                    .reply({
+                    text: 'An error occurred while processing the selection.',
+                    ephemeral: true,
+                })
+                    .catch(() => { });
+                return;
+            }
+        }
+        logger_1.logger.warn(`[SelectHandler] No handler for customId: ${interaction.customId}`);
+    };
+}

package/dist/handlers/templateButtonAction.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Platform-agnostic ButtonAction for template execution interactions.
+ *
+ * When a template button is clicked, the template prompt is injected into
+ * Antigravity via CDP. The user receives a confirmation message.
+ *
+ * Handles: template_btn_<id>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplateButtonAction = createTemplateButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const templateUi_1 = require("../ui/templateUi");
+const logger_1 = require("../utils/logger");
+function createTemplateButtonAction(deps) {
+    return {
+        match(customId) {
+            if (!customId.startsWith(templateUi_1.TEMPLATE_BTN_PREFIX))
+                return null;
+            const id = (0, templateUi_1.parseTemplateButtonId)(customId);
+            if (isNaN(id))
+                return null;
+            return { templateId: String(id) };
+        },
+        async execute(interaction, params) {
+            const templateId = parseInt(params.templateId, 10);
+            const template = deps.templateRepo.findById(templateId);
+            if (!template) {
+                await interaction.reply({ text: 'Template not found. It may have been deleted.' }).catch(() => { });
+                return;
+            }
+            await interaction.deferUpdate();
+            const cdp = (0, cdpBridgeManager_1.getCurrentCdp)(deps.bridge);
+            if (!cdp) {
+                await interaction.followUp({
+                    text: 'Not connected to Antigravity. Send the prompt as a message instead.',
+                }).catch(() => { });
+                return;
+            }
+            // Inject the template prompt
+            logger_1.logger.info(`[TemplateButton] Executing template "${template.name}" (id=${template.id})`);
+            const result = await cdp.injectMessage(template.prompt);
+            if (!result.ok) {
+                await interaction.followUp({
+                    text: `Failed to execute template: ${result.error}`,
+                }).catch(() => { });
+                return;
+            }
+            await interaction.followUp({
+                text: `Executing template: ${template.name}`,
+            }).catch(() => { });
+        },
+    };
+}

package/dist/platform/adapter.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Platform adapter interface.
+ *
+ * Each messaging platform (Discord, Telegram, etc.) implements this interface
+ * to provide a unified event-driven API for the bot core.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/platform/discord/discordAdapter.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Discord adapter implementing the PlatformAdapter interface.
+ *
+ * Bridges discord.js Client events into platform-agnostic callbacks,
+ * allowing the bot core to operate independently of Discord specifics.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordAdapter = void 0;
+const discord_js_1 = require("discord.js");
+const wrappers_1 = require("./wrappers");
+class DiscordAdapter {
+    platform = 'discord';
+    client;
+    botUserId = '';
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Start listening for Discord events and forward them
+     * through the platform-agnostic event callbacks.
+     */
+    async start(events) {
+        // Ready event: capture bot user ID and notify
+        this.client.once(discord_js_1.Events.ClientReady, (readyClient) => {
+            this.botUserId = readyClient.user.id;
+            events.onReady?.();
+        });
+        // Message create
+        if (events.onMessage) {
+            const onMessage = events.onMessage;
+            this.client.on(discord_js_1.Events.MessageCreate, async (message) => {
+                try {
+                    const wrapped = (0, wrappers_1.wrapDiscordMessage)(message);
+                    await onMessage(wrapped);
+                }
+                catch (error) {
+                    events.onError?.(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        }
+        // Interaction create (buttons, selects, commands)
+        if (events.onButtonInteraction || events.onSelectInteraction || events.onCommandInteraction) {
+            this.client.on(discord_js_1.Events.InteractionCreate, async (interaction) => {
+                try {
+                    if (interaction.isButton() && events.onButtonInteraction) {
+                        const wrapped = (0, wrappers_1.wrapDiscordButton)(interaction);
+                        await events.onButtonInteraction(wrapped);
+                    }
+                    else if (interaction.isStringSelectMenu() && events.onSelectInteraction) {
+                        const wrapped = (0, wrappers_1.wrapDiscordSelect)(interaction);
+                        await events.onSelectInteraction(wrapped);
+                    }
+                    else if (interaction.isChatInputCommand() && events.onCommandInteraction) {
+                        const wrapped = (0, wrappers_1.wrapDiscordCommand)(interaction);
+                        await events.onCommandInteraction(wrapped);
+                    }
+                }
+                catch (error) {
+                    events.onError?.(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        }
+        // Client error forwarding
+        this.client.on(discord_js_1.Events.Error, (error) => {
+            events.onError?.(error);
+        });
+    }
+    /** Stop the adapter by destroying the discord.js Client. */
+    async stop() {
+        this.client.destroy();
+    }
+    /**
+     * Retrieve a channel by its Discord snowflake ID.
+     * Returns null if the channel is not found, not fetchable, or not text-based.
+     */
+    async getChannel(channelId) {
+        try {
+            const channel = await this.client.channels.fetch(channelId);
+            if (!channel)
+                return null;
+            if (!channel.isTextBased())
+                return null;
+            return (0, wrappers_1.wrapDiscordChannel)(channel);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Return the bot's own user ID. Empty string before start() completes. */
+    getBotUserId() {
+        return this.botUserId;
+    }
+    /** Access the raw discord.js Client for platform-specific features. */
+    getRawClient() {
+        return this.client;
+    }
+}
+exports.DiscordAdapter = DiscordAdapter;

package/dist/platform/discord/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDiscordButtonStyle = exports.toDiscordPayload = exports.wrapDiscordSentMessage = exports.wrapDiscordCommand = exports.wrapDiscordSelect = exports.wrapDiscordButton = exports.wrapDiscordMessage = exports.wrapDiscordChannel = exports.wrapDiscordUser = exports.DiscordAdapter = void 0;
+var discordAdapter_1 = require("./discordAdapter");
+Object.defineProperty(exports, "DiscordAdapter", { enumerable: true, get: function () { return discordAdapter_1.DiscordAdapter; } });
+var wrappers_1 = require("./wrappers");
+Object.defineProperty(exports, "wrapDiscordUser", { enumerable: true, get: function () { return wrappers_1.wrapDiscordUser; } });
+Object.defineProperty(exports, "wrapDiscordChannel", { enumerable: true, get: function () { return wrappers_1.wrapDiscordChannel; } });
+Object.defineProperty(exports, "wrapDiscordMessage", { enumerable: true, get: function () { return wrappers_1.wrapDiscordMessage; } });
+Object.defineProperty(exports, "wrapDiscordButton", { enumerable: true, get: function () { return wrappers_1.wrapDiscordButton; } });
+Object.defineProperty(exports, "wrapDiscordSelect", { enumerable: true, get: function () { return wrappers_1.wrapDiscordSelect; } });
+Object.defineProperty(exports, "wrapDiscordCommand", { enumerable: true, get: function () { return wrappers_1.wrapDiscordCommand; } });
+Object.defineProperty(exports, "wrapDiscordSentMessage", { enumerable: true, get: function () { return wrappers_1.wrapDiscordSentMessage; } });
+Object.defineProperty(exports, "toDiscordPayload", { enumerable: true, get: function () { return wrappers_1.toDiscordPayload; } });
+Object.defineProperty(exports, "toDiscordButtonStyle", { enumerable: true, get: function () { return wrappers_1.toDiscordButtonStyle; } });