lazy-gravity 0.2.0 → 0.3.0

package/dist/database/userPreferenceRepository.js

@@ -12,7 +12,7 @@ class UserPreferenceRepository {
         this.initialize();
     }
     /**
-     * Initialize table (create if not exists)
+     * Initialize table (create if not exists) and run migrations
      */
     initialize() {
         this.db.exec(`
@@ -24,6 +24,29 @@ class UserPreferenceRepository {
                 updated_at TEXT NOT NULL DEFAULT (datetime('now'))
             )
         `);
+        this.migrateDefaultModel();
+    }
+    /**
+     * Safe migration: add default_model column if it does not exist.
+     * Uses pragma when available, falls back to try/catch ALTER TABLE.
+     */
+    migrateDefaultModel() {
+        if (typeof this.db.pragma === 'function') {
+            const columns = this.db.pragma('table_info(user_preferences)');
+            const hasColumn = columns.some(c => c.name === 'default_model');
+            if (!hasColumn) {
+                this.db.exec('ALTER TABLE user_preferences ADD COLUMN default_model TEXT DEFAULT NULL');
+            }
+        }
+        else {
+            // Fallback for mock/alternate DB implementations without pragma
+            try {
+                this.db.exec('ALTER TABLE user_preferences ADD COLUMN default_model TEXT DEFAULT NULL');
+            }
+            catch {
+                // Column already exists — safe to ignore
+            }
+        }
     }
     /**
      * Get the output format preference for a user.
@@ -47,6 +70,27 @@ class UserPreferenceRepository {
                           updated_at = datetime('now')
         `).run(userId, format);
     }
+    /**
+     * Get the default model for a user.
+     * Returns null if no default is stored.
+     */
+    getDefaultModel(userId) {
+        const row = this.db.prepare('SELECT default_model FROM user_preferences WHERE user_id = ?').get(userId);
+        return row?.default_model ?? null;
+    }
+    /**
+     * Set the default model for a user (upsert).
+     * Pass null to clear the default.
+     */
+    setDefaultModel(userId, modelName) {
+        this.db.prepare(`
+            INSERT INTO user_preferences (user_id, default_model)
+            VALUES (?, ?)
+            ON CONFLICT(user_id)
+            DO UPDATE SET default_model = excluded.default_model,
+                          updated_at = datetime('now')
+        `).run(userId, modelName);
+    }
     /**
      * Get full preference record for a user
      */
@@ -64,6 +108,7 @@ class UserPreferenceRepository {
             id: row.id,
             userId: row.user_id,
             outputFormat: row.output_format,
+            defaultModel: row.default_model ?? null,
             createdAt: row.created_at,
             updatedAt: row.updated_at,
         };

package/dist/events/interactionCreateHandler.js

@@ -378,6 +378,42 @@ function createInteractionCreateHandler(deps) {
                     await deps.cleanupHandler.handleCancel(interaction);
                     return;
                 }
+                if (interaction.customId === 'model_set_default_btn') {
+                    await interaction.deferUpdate();
+                    const cdp = deps.getCurrentCdp(deps.bridge);
+                    if (!cdp) {
+                        await interaction.followUp({ content: 'Not connected to CDP.', flags: discord_js_1.MessageFlags.Ephemeral });
+                        return;
+                    }
+                    const currentModel = await cdp.getCurrentModel();
+                    if (!currentModel) {
+                        await interaction.followUp({ content: 'No current model detected.', flags: discord_js_1.MessageFlags.Ephemeral });
+                        return;
+                    }
+                    deps.modelService.setDefaultModel(currentModel);
+                    if (deps.userPrefRepo) {
+                        deps.userPrefRepo.setDefaultModel(interaction.user.id, currentModel);
+                    }
+                    await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
+                        getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                        fetchQuota: async () => deps.bridge.quota.fetchQuota(),
+                    });
+                    await interaction.followUp({ content: `Default model set to **${currentModel}**.`, flags: discord_js_1.MessageFlags.Ephemeral });
+                    return;
+                }
+                if (interaction.customId === 'model_clear_default_btn') {
+                    await interaction.deferUpdate();
+                    deps.modelService.setDefaultModel(null);
+                    if (deps.userPrefRepo) {
+                        deps.userPrefRepo.setDefaultModel(interaction.user.id, null);
+                    }
+                    await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {
+                        getCurrentCdp: () => deps.getCurrentCdp(deps.bridge),
+                        fetchQuota: async () => deps.bridge.quota.fetchQuota(),
+                    });
+                    await interaction.followUp({ content: 'Default model cleared.', flags: discord_js_1.MessageFlags.Ephemeral });
+                    return;
+                }
                 if (interaction.customId === 'model_refresh_btn') {
                     await interaction.deferUpdate();
                     await deps.sendModelsUI({ editReply: async (data) => await interaction.editReply(data) }, {

package/dist/events/messageCreateHandler.js

@@ -4,6 +4,7 @@ exports.createMessageCreateHandler = createMessageCreateHandler;
 const discord_js_1 = require("discord.js");
 const messageParser_1 = require("../commands/messageParser");
 const plainTextFormatter_1 = require("../utils/plainTextFormatter");
+const wrappers_1 = require("../platform/discord/wrappers");
 const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
 const modeService_1 = require("../services/modeService");
 const imageHandler_1 = require("../utils/imageHandler");
@@ -115,6 +116,7 @@ function createMessageCreateHandler(deps) {
                         channelManager: deps.channelManager,
                         titleGenerator: deps.titleGenerator,
                         userPrefRepo: deps.userPrefRepo,
+                        extractionMode: deps.config.extractionMode,
                     });
                 }
                 else {
@@ -162,14 +164,15 @@ function createMessageCreateHandler(deps) {
                             const cdp = await deps.bridge.pool.getOrConnect(workspacePath);
                             const projectName = deps.bridge.pool.extractProjectName(workspacePath);
                             deps.bridge.lastActiveWorkspace = projectName;
-                            deps.bridge.lastActiveChannel = message.channel;
-                            registerApprovalWorkspaceChannel(deps.bridge, projectName, message.channel);
-                            ensureApprovalDetector(deps.bridge, cdp, projectName, deps.client);
-                            ensureErrorPopupDetector(deps.bridge, cdp, projectName, deps.client);
-                            ensurePlanningDetector(deps.bridge, cdp, projectName, deps.client);
+                            const platformChannel = (0, wrappers_1.wrapDiscordChannel)(message.channel);
+                            deps.bridge.lastActiveChannel = platformChannel;
+                            registerApprovalWorkspaceChannel(deps.bridge, projectName, platformChannel);
+                            ensureApprovalDetector(deps.bridge, cdp, projectName);
+                            ensureErrorPopupDetector(deps.bridge, cdp, projectName);
+                            ensurePlanningDetector(deps.bridge, cdp, projectName);
                             const session = deps.chatSessionRepo.findByChannelId(message.channelId);
                             if (session?.displayName) {
-                                registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, message.channel);
+                                registerApprovalSessionChannel(deps.bridge, projectName, session.displayName, platformChannel);
                             }
                             if (session?.isRenamed && session.displayName) {
                                 const activationResult = await deps.chatSessionService.activateSessionByTitle(cdp, session.displayName);
@@ -197,7 +200,7 @@ function createMessageCreateHandler(deps) {
                             // Re-register session channel after autoRenameChannel sets displayName
                             const updatedSession = deps.chatSessionRepo.findByChannelId(message.channelId);
                             if (updatedSession?.displayName) {
-                                registerApprovalSessionChannel(deps.bridge, projectName, updatedSession.displayName, message.channel);
+                                registerApprovalSessionChannel(deps.bridge, projectName, updatedSession.displayName, platformChannel);
                             }
                             // Register echo hash so UserMessageDetector skips this message
                             const userMsgDetector = deps.bridge.pool.getUserMessageDetector?.(projectName);
@@ -232,6 +235,7 @@ function createMessageCreateHandler(deps) {
                                     channelManager: deps.channelManager,
                                     titleGenerator: deps.titleGenerator,
                                     userPrefRepo: deps.userPrefRepo,
+                                    extractionMode: deps.config.extractionMode,
                                     onFullCompletion: settle,
                                 }).catch((err) => {
                                     // sendPromptToAntigravity rejected before onFullCompletion fired

package/dist/handlers/approvalButtonAction.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * Platform-agnostic approval button action.
+ *
+ * Handles Allow / Always Allow / Deny button presses from both Discord
+ * and Telegram using the ButtonAction interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApprovalButtonAction = createApprovalButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const logger_1 = require("../utils/logger");
+function createApprovalButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, cdpBridgeManager_1.parseApprovalCustomId)(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(() => { });
+            // Channel scope check (skip if no channelId was encoded)
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This approval action is linked to a different session channel.' })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            logger_1.logger.debug(`[ApprovalAction] action=${action} project=${projectName ?? 'null'} channel=${interaction.channel.id}`);
+            const detector = projectName
+                ? deps.bridge.pool.getApprovalDetector(projectName)
+                : undefined;
+            if (!detector) {
+                logger_1.logger.warn(`[ApprovalAction] No detector for project=${projectName}`);
+                await interaction
+                    .reply({ text: 'Approval detector not found.' })
+                    .catch(() => { });
+                return;
+            }
+            const lastInfo = detector.getLastDetectedInfo();
+            logger_1.logger.debug(`[ApprovalAction] lastDetectedInfo: ${lastInfo ? JSON.stringify(lastInfo) : 'null'}`);
+            let success = false;
+            let actionLabel = '';
+            try {
+                if (action === 'approve') {
+                    success = await detector.approveButton();
+                    actionLabel = 'Allow';
+                }
+                else if (action === 'always_allow') {
+                    success = await detector.alwaysAllowButton();
+                    actionLabel = 'Allow Chat';
+                }
+                else {
+                    success = await detector.denyButton();
+                    actionLabel = 'Deny';
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger_1.logger.error(`[ApprovalAction] CDP click failed: ${msg}`);
+                await interaction
+                    .reply({ text: `Approval failed: ${msg}` })
+                    .catch(() => { });
+                return;
+            }
+            logger_1.logger.debug(`[ApprovalAction] ${actionLabel} result: ${success}`);
+            if (success) {
+                // Remove buttons by editing the original message.
+                // If update() fails, fall back to editReply(), then followUp().
+                const updatePayload = { text: `✅ ${actionLabel} completed`, components: [] };
+                try {
+                    await interaction.update(updatePayload);
+                }
+                catch (updateErr) {
+                    logger_1.logger.warn('[ApprovalAction] update failed, trying editReply:', updateErr);
+                    try {
+                        await interaction.editReply(updatePayload);
+                    }
+                    catch (editErr) {
+                        logger_1.logger.warn('[ApprovalAction] editReply failed, sending followUp:', editErr);
+                        await interaction.followUp({ text: `✅ ${actionLabel} completed` }).catch(() => { });
+                    }
+                }
+            }
+            else {
+                await interaction
+                    .reply({ text: 'Approval button not found.' })
+                    .catch(() => { });
+            }
+        },
+    };
+}

package/dist/handlers/autoAcceptButtonAction.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Platform-agnostic ButtonAction for auto-accept toggle interactions.
+ *
+ * Handles:
+ *   autoaccept_btn_on      — Enable auto-accept
+ *   autoaccept_btn_off     — Disable auto-accept
+ *   autoaccept_btn_refresh — Refresh the auto-accept UI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutoAcceptButtonAction = createAutoAcceptButtonAction;
+const autoAcceptUi_1 = require("../ui/autoAcceptUi");
+function createAutoAcceptButtonAction(deps) {
+    return {
+        match(customId) {
+            if (customId === autoAcceptUi_1.AUTOACCEPT_BTN_ON)
+                return { action: 'on' };
+            if (customId === autoAcceptUi_1.AUTOACCEPT_BTN_OFF)
+                return { action: 'off' };
+            if (customId === autoAcceptUi_1.AUTOACCEPT_BTN_REFRESH)
+                return { action: 'refresh' };
+            return null;
+        },
+        async execute(interaction, params) {
+            await interaction.deferUpdate();
+            if (params.action === 'on' || params.action === 'off') {
+                const result = deps.autoAcceptService.handle(params.action);
+                // Only update UI if the state actually changed to avoid
+                // Telegram "message is not modified" error.
+                if (result.changed) {
+                    const payload = (0, autoAcceptUi_1.buildAutoAcceptPayload)(deps.autoAcceptService.isEnabled());
+                    await interaction.update(payload);
+                }
+                await interaction.followUp({ text: result.message }).catch(() => { });
+            }
+            else {
+                // refresh — always update to show latest state
+                const payload = (0, autoAcceptUi_1.buildAutoAcceptPayload)(deps.autoAcceptService.isEnabled());
+                await interaction.update(payload);
+            }
+        },
+    };
+}

package/dist/handlers/buttonHandler.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Platform-agnostic button interaction handler.
+ *
+ * Uses a registry pattern: each button type registers a match+execute pair.
+ * The first matching action wins (order matters).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlatformButtonHandler = createPlatformButtonHandler;
+const logger_1 = require("../utils/logger");
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a platform-agnostic button interaction handler.
+ * Returns an async function that processes PlatformButtonInteraction events.
+ */
+function createPlatformButtonHandler(deps) {
+    return async (interaction) => {
+        for (const action of deps.actions) {
+            let params;
+            try {
+                params = action.match(interaction.customId);
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                logger_1.logger.error('[ButtonHandler] Match error:', errorMessage);
+                await interaction
+                    .reply({
+                    text: 'An error occurred while processing the button action.',
+                    ephemeral: true,
+                })
+                    .catch(() => { });
+                return;
+            }
+            if (params !== null) {
+                try {
+                    await action.execute(interaction, params);
+                }
+                catch (err) {
+                    const errorMessage = err instanceof Error ? err.message : String(err);
+                    logger_1.logger.error('[ButtonHandler] Action error:', errorMessage);
+                    await interaction
+                        .reply({
+                        text: 'An error occurred while processing the button action.',
+                        ephemeral: true,
+                    })
+                        .catch(() => { });
+                }
+                return;
+            }
+        }
+        logger_1.logger.warn(`[ButtonHandler] No handler for customId: ${interaction.customId}`);
+    };
+}

package/dist/handlers/commandHandler.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Platform-agnostic slash command handler.
+ *
+ * Maintains a lookup map from command name to CommandDef for O(1) dispatch.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlatformCommandHandler = createPlatformCommandHandler;
+const logger_1 = require("../utils/logger");
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a platform-agnostic slash command handler.
+ * Returns an async function that processes PlatformCommandInteraction events.
+ */
+function createPlatformCommandHandler(deps) {
+    const commandMap = new Map();
+    for (const cmd of deps.commands) {
+        commandMap.set(cmd.name, cmd);
+    }
+    return async (interaction) => {
+        const cmd = commandMap.get(interaction.commandName);
+        if (!cmd) {
+            logger_1.logger.warn(`[CommandHandler] Unknown command: ${interaction.commandName}`);
+            await interaction.editReply({
+                text: `Unknown command: ${interaction.commandName}`,
+            }).catch(() => { });
+            return;
+        }
+        try {
+            await cmd.execute(interaction);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            logger_1.logger.error(`[CommandHandler] Command "${interaction.commandName}" error:`, errorMessage);
+            await interaction
+                .editReply({
+                text: 'An error occurred while processing the command.',
+            })
+                .catch(() => { });
+        }
+    };
+}

package/dist/handlers/errorPopupButtonAction.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Platform-agnostic error popup button action.
+ *
+ * Handles Dismiss / Copy Debug / Retry button presses for the error
+ * popup dialog from both Discord and Telegram using the ButtonAction interface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createErrorPopupButtonAction = createErrorPopupButtonAction;
+const cdpBridgeManager_1 = require("../services/cdpBridgeManager");
+const logger_1 = require("../utils/logger");
+const MAX_DEBUG_CONTENT = 4096;
+function createErrorPopupButtonAction(deps) {
+    return {
+        match(customId) {
+            const parsed = (0, cdpBridgeManager_1.parseErrorPopupCustomId)(customId);
+            if (!parsed)
+                return null;
+            return {
+                action: parsed.action,
+                projectName: parsed.projectName ?? '',
+                channelId: parsed.channelId ?? '',
+            };
+        },
+        async execute(interaction, params) {
+            const { action, channelId } = params;
+            if (channelId && channelId !== interaction.channel.id) {
+                await interaction
+                    .reply({ text: 'This error popup action is linked to a different session channel.' })
+                    .catch(() => { });
+                return;
+            }
+            const projectName = params.projectName || deps.bridge.lastActiveWorkspace;
+            const detector = projectName
+                ? deps.bridge.pool.getErrorPopupDetector(projectName)
+                : undefined;
+            if (!detector) {
+                await interaction
+                    .reply({ text: 'Error popup detector not found.' })
+                    .catch(() => { });
+                return;
+            }
+            // Acknowledge immediately so Telegram doesn't time out
+            await interaction.deferUpdate().catch(() => { });
+            if (action === 'dismiss') {
+                let clicked = false;
+                try {
+                    clicked = await detector.clickDismissButton();
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger_1.logger.error(`[ErrorPopupAction] CDP click failed: ${msg}`);
+                    await interaction.reply({ text: `Dismiss failed: ${msg}` }).catch(() => { });
+                    return;
+                }
+                if (clicked) {
+                    await interaction
+                        .update({
+                        text: '🗑️ Dismissed',
+                        components: [],
+                    })
+                        .catch((err) => {
+                        logger_1.logger.warn('[ErrorPopupAction] update failed:', err);
+                    });
+                }
+                else {
+                    await interaction
+                        .reply({ text: 'Dismiss button not found.' })
+                        .catch(() => { });
+                }
+            }
+            else if (action === 'copy_debug') {
+                const clicked = await detector.clickCopyDebugInfoButton();
+                if (!clicked) {
+                    await interaction
+                        .reply({ text: 'Copy debug info button not found.' })
+                        .catch(() => { });
+                    return;
+                }
+                // Wait for clipboard to be populated
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                const clipboardContent = await detector.readClipboard();
+                await interaction
+                    .update({
+                    text: '📋 Debug info copied',
+                    components: [],
+                })
+                    .catch((err) => {
+                    logger_1.logger.warn('[ErrorPopupAction] update failed:', err);
+                });
+                if (clipboardContent) {
+                    const truncated = clipboardContent.length > MAX_DEBUG_CONTENT
+                        ? clipboardContent.substring(0, MAX_DEBUG_CONTENT - 15) + '\n\n(truncated)'
+                        : clipboardContent;
+                    await interaction
+                        .followUp({ text: truncated })
+                        .catch((err) => {
+                        logger_1.logger.warn('[ErrorPopupAction] followUp failed:', err);
+                    });
+                }
+                else {
+                    await interaction
+                        .followUp({ text: 'Could not read debug info from clipboard.' })
+                        .catch(() => { });
+                }
+            }
+            else {
+                // Retry action
+                let clicked = false;
+                try {
+                    clicked = await detector.clickRetryButton();
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger_1.logger.error(`[ErrorPopupAction] CDP click failed: ${msg}`);
+                    await interaction.reply({ text: `Retry failed: ${msg}` }).catch(() => { });
+                    return;
+                }
+                if (clicked) {
+                    await interaction
+                        .update({
+                        text: '🔄 Retry initiated',
+                        components: [],
+                    })
+                        .catch((err) => {
+                        logger_1.logger.warn('[ErrorPopupAction] update failed:', err);
+                    });
+                }
+                else {
+                    await interaction
+                        .reply({ text: 'Retry button not found.' })
+                        .catch(() => { });
+                }
+            }
+        },
+    };
+}

package/dist/handlers/messageHandler.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Platform-agnostic message handler.
+ *
+ * Extracts core message-handling logic from Discord-specific event handlers
+ * into a platform-independent factory that works with any PlatformMessage.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlatformMessageHandler = createPlatformMessageHandler;
+const logger_1 = require("../utils/logger");
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a platform-agnostic message handler.
+ * Returns an async function that processes PlatformMessage events.
+ */
+function createPlatformMessageHandler(deps) {
+    return async (message) => {
+        // Skip bot messages
+        if (message.author.isBot)
+            return;
+        const content = message.content.trim();
+        if (!content && message.attachments.length === 0)
+            return;
+        // Check for text commands (prefixed with !)
+        if (content.startsWith('!')) {
+            const parts = content.slice(1).split(/\s+/);
+            const commandName = parts[0]?.toLowerCase();
+            const args = parts.slice(1);
+            if (commandName && deps.handleTextCommand) {
+                try {
+                    const handled = await deps.handleTextCommand(message, commandName, args);
+                    if (handled)
+                        return;
+                }
+                catch (err) {
+                    const errorMessage = err instanceof Error ? err.message : String(err);
+                    logger_1.logger.error('[MessageHandler] Text command error:', errorMessage);
+                    await message
+                        .reply({
+                        text: 'An error occurred while processing the command.',
+                    })
+                        .catch(() => { });
+                    return;
+                }
+            }
+        }
+        // Route to workspace
+        const workspacePath = deps.getWorkspaceForChannel(message.channel.id);
+        if (!workspacePath) {
+            await message.reply({
+                text: 'No project is configured for this channel. Please create or select one with `/project`.',
+            });
+            return;
+        }
+        const promptText = content ||
+            'Please review the attached images and respond accordingly.';
+        try {
+            await deps.sendPrompt(message, workspacePath, promptText);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            logger_1.logger.error('[MessageHandler] Failed to send prompt:', errorMessage);
+            await message
+                .reply({ text: 'An error occurred while processing your message.' })
+                .catch(() => { });
+        }
+    };
+}