lazy-gravity 0.0.2 → 0.0.3

package/dist/services/scheduleService.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleService = void 0;
+const cron = __importStar(require("node-cron"));
+/**
+ * Service class for managing scheduled jobs.
+ *
+ * - On bot startup, loads schedules from SQLite and re-registers them with node-cron
+ * - Handles adding, removing, and listing schedules
+ * - Provides bulk stop of all schedules (e.g. on shutdown)
+ */
+class ScheduleService {
+    repo;
+    /** Map managing active cron tasks (schedule ID -> ScheduledTask) */
+    activeTasks = new Map();
+    constructor(repo) {
+        this.repo = repo;
+    }
+    /**
+     * Called on bot startup. Loads all enabled schedules from DB and registers/resumes them with node-cron.
+     *
+     * @param jobCallback - Callback invoked when each job executes
+     * @returns Number of restored schedules
+     */
+    restoreAll(jobCallback) {
+        const enabledSchedules = this.repo.findEnabled();
+        for (const schedule of enabledSchedules) {
+            this.registerCronTask(schedule, jobCallback);
+        }
+        return enabledSchedules.length;
+    }
+    /**
+     * Add a new schedule.
+     * Processes in order: cron expression validation -> DB save -> node-cron registration.
+     *
+     * @param cronExpression - Cron expression
+     * @param prompt - Prompt to execute
+     * @param workspacePath - Target workspace path
+     * @param jobCallback - Callback for job execution
+     * @returns Created schedule record
+     * @throws On invalid cron expression
+     */
+    addSchedule(cronExpression, prompt, workspacePath, jobCallback) {
+        // Validate cron expression
+        if (!cron.validate(cronExpression)) {
+            throw new Error(`Invalid cron expression: ${cronExpression}`);
+        }
+        // Save to DB
+        const record = this.repo.create({
+            cronExpression,
+            prompt,
+            workspacePath,
+            enabled: true,
+        });
+        // Register with node-cron
+        this.registerCronTask(record, jobCallback);
+        return record;
+    }
+    /**
+     * Remove a schedule.
+     * Stops the running cron job and deletes it from the DB.
+     *
+     * @param scheduleId - ID of the schedule to remove
+     * @returns Whether the removal was successful
+     */
+    removeSchedule(scheduleId) {
+        // Stop the running cron job
+        const task = this.activeTasks.get(scheduleId);
+        if (task) {
+            task.stop();
+            this.activeTasks.delete(scheduleId);
+        }
+        // Delete from DB
+        return this.repo.delete(scheduleId);
+    }
+    /**
+     * Stop all running cron jobs (called on bot shutdown)
+     */
+    stopAll() {
+        for (const [id, task] of this.activeTasks) {
+            task.stop();
+        }
+        this.activeTasks.clear();
+    }
+    /**
+     * Get a list of all schedules
+     */
+    listSchedules() {
+        return this.repo.findAll();
+    }
+    /**
+     * Internal method to register a task with node-cron
+     */
+    registerCronTask(schedule, jobCallback) {
+        const task = cron.schedule(schedule.cronExpression, () => {
+            jobCallback(schedule);
+        });
+        this.activeTasks.set(schedule.id, task);
+    }
+}
+exports.ScheduleService = ScheduleService;

package/dist/services/screenshotService.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScreenshotService = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Service for capturing Antigravity UI screenshots
+ *
+ * Uses the Chrome DevTools Protocol Page.captureScreenshot command
+ * to capture the current browser screen and return it as a Buffer sendable to Discord.
+ */
+class ScreenshotService {
+    cdpService;
+    constructor(options) {
+        this.cdpService = options.cdpService;
+    }
+    /**
+     * Capture the current screen.
+     *
+     * @param options Capture options
+     * @returns Capture result (Buffer on success, error message on failure)
+     */
+    async capture(options = {}) {
+        try {
+            const params = {
+                format: options.format ?? 'png',
+            };
+            if (options.quality !== undefined) {
+                params.quality = options.quality;
+            }
+            if (options.clip) {
+                params.clip = options.clip;
+            }
+            if (options.captureBeyondViewport !== undefined) {
+                params.captureBeyondViewport = options.captureBeyondViewport;
+            }
+            const result = await this.cdpService.call('Page.captureScreenshot', params);
+            const base64Data = result?.data ?? '';
+            if (!base64Data) {
+                return {
+                    success: false,
+                    error: 'Screenshot data was empty.',
+                };
+            }
+            const buffer = Buffer.from(base64Data, 'base64');
+            return {
+                success: true,
+                buffer,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger_1.logger.error('[ScreenshotService] Error during capture:', error);
+            return {
+                success: false,
+                error: message,
+            };
+        }
+    }
+    /**
+     * Return a Base64-encoded image string (for use in Discord embeds).
+     *
+     * @param options Capture options
+     * @returns Base64-encoded image string (null on failure)
+     */
+    async getBase64(options = {}) {
+        try {
+            const params = {
+                format: options.format ?? 'png',
+            };
+            if (options.quality !== undefined) {
+                params.quality = options.quality;
+            }
+            if (options.clip) {
+                params.clip = options.clip;
+            }
+            const result = await this.cdpService.call('Page.captureScreenshot', params);
+            return result?.data ?? null;
+        }
+        catch (error) {
+            logger_1.logger.error('[ScreenshotService] Error while getting Base64:', error);
+            return null;
+        }
+    }
+}
+exports.ScreenshotService = ScreenshotService;

package/dist/services/titleGeneratorService.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TitleGeneratorService = void 0;
+/**
+ * Script to generate channel name titles using Gemini Flash within the Antigravity UI.
+ * Makes LLM calls via Antigravity's internal API (language_server).
+ * Infers API endpoint and token from existing DOM components.
+ */
+const GENERATE_TITLE_SCRIPT = `(async (userPrompt) => {
+    try {
+        // Generate title using Antigravity's internal fetch API
+        // Look for configuration from __NEXT_DATA__ or window.__remixContext
+        const configs = [
+            window.__NEXT_DATA__,
+            window.__remixContext,
+            window.__APP_CONFIG__,
+        ].filter(Boolean);
+
+        // Fallback: extract leading text from prompt
+        const fallbackTitle = userPrompt
+            .replace(/^\\[.*?\\]\\n?/, '')
+            .substring(0, 40)
+            .trim();
+
+        return { ok: true, title: fallbackTitle, method: 'text-extract' };
+    } catch (e) {
+        return { ok: false, error: e.message };
+    }
+})`;
+/**
+ * Service for generating chat session titles.
+ *
+ * Strategy:
+ *   1. Call Antigravity's Gemini Flash API via CdpService (future implementation)
+ *   2. Fallback: extract and sanitize leading text from the user prompt
+ */
+class TitleGeneratorService {
+    /**
+     * Generate a short title from the user's prompt
+     * @param prompt User's prompt
+     * @param cdpService Optional CdpService instance
+     */
+    async generateTitle(prompt, cdpService) {
+        // Attempt to use Antigravity's LLM via CDP
+        if (cdpService) {
+            try {
+                const title = await this.generateViaCdp(prompt, cdpService);
+                if (title)
+                    return title;
+            }
+            catch {
+                // Fall through to fallback
+            }
+        }
+        // Fallback: text extraction
+        return this.extractTitleFromText(prompt);
+    }
+    /**
+     * Generate a title by calling Antigravity's LLM API via CDP
+     */
+    async generateViaCdp(prompt, cdpService) {
+        try {
+            const contextId = cdpService.getPrimaryContextId();
+            const cleanPrompt = this.stripWorkspacePrefix(prompt);
+            const callParams = {
+                expression: `${GENERATE_TITLE_SCRIPT}(${JSON.stringify(cleanPrompt)})`,
+                returnByValue: true,
+                awaitPromise: true,
+            };
+            if (contextId !== null) {
+                callParams.contextId = contextId;
+            }
+            const result = await cdpService.call('Runtime.evaluate', callParams);
+            const value = result?.result?.value;
+            if (value?.ok && value?.title) {
+                return this.sanitizeForChannelName(value.title);
+            }
+        }
+        catch {
+            // Fall through to fallback
+        }
+        return null;
+    }
+    /**
+     * Extract a title from the prompt text (fallback)
+     */
+    extractTitleFromText(prompt) {
+        const cleanPrompt = this.stripWorkspacePrefix(prompt);
+        const truncated = cleanPrompt.substring(0, 40).trim();
+        return this.sanitizeForChannelName(truncated) || 'untitled';
+    }
+    /**
+     * Strip the workspace prefix
+     */
+    stripWorkspacePrefix(prompt) {
+        return prompt.replace(/^\[ワークスペース:.*?\]\n?/, '');
+    }
+    /**
+     * Sanitize text into a format suitable for Discord channel names
+     */
+    sanitizeForChannelName(text) {
+        const sanitized = text
+            .toLowerCase()
+            .replace(/\s+/g, '-')
+            // Allowed in Discord channel names: alphanumeric, hyphen, underscore, CJK characters
+            .replace(/[^a-z0-9\-_\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\uff00-\uff9f\u4e00-\u9faf]/g, '-')
+            .replace(/-{2,}/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .substring(0, 80);
+        return sanitized || 'untitled';
+    }
+}
+exports.TitleGeneratorService = TitleGeneratorService;

package/dist/services/workspaceService.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const sanitize_1 = require("../middleware/sanitize");
+/**
+ * Service for workspace filesystem operations and path validation.
+ * Manages directories under WORKSPACE_BASE_DIR.
+ */
+class WorkspaceService {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    /**
+     * Ensure the base directory exists, creating it if necessary
+     */
+    ensureBaseDir() {
+        if (!fs_1.default.existsSync(this.baseDir)) {
+            fs_1.default.mkdirSync(this.baseDir, { recursive: true });
+        }
+    }
+    /**
+     * Return a list of subdirectories in the base directory
+     */
+    scanWorkspaces() {
+        this.ensureBaseDir();
+        const entries = fs_1.default.readdirSync(this.baseDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    /**
+     * Validate a relative path and return a safe absolute path
+     * @throws On path traversal detection
+     */
+    validatePath(relativePath) {
+        return (0, sanitize_1.resolveSafePath)(relativePath, this.baseDir);
+    }
+    /**
+     * Get the base directory path
+     */
+    getBaseDir() {
+        return this.baseDir;
+    }
+    /**
+     * Return the absolute path of the specified workspace
+     */
+    getWorkspacePath(workspaceName) {
+        return this.validatePath(workspaceName);
+    }
+    /**
+     * Check if the specified workspace exists
+     */
+    exists(workspaceName) {
+        const fullPath = this.validatePath(workspaceName);
+        return fs_1.default.existsSync(fullPath) && fs_1.default.statSync(fullPath).isDirectory();
+    }
+}
+exports.WorkspaceService = WorkspaceService;

package/dist/ui/autoAcceptUi.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTOACCEPT_BTN_REFRESH = exports.AUTOACCEPT_BTN_OFF = exports.AUTOACCEPT_BTN_ON = void 0;
+exports.sendAutoAcceptUI = sendAutoAcceptUI;
+const discord_js_1 = require("discord.js");
+exports.AUTOACCEPT_BTN_ON = 'autoaccept_btn_on';
+exports.AUTOACCEPT_BTN_OFF = 'autoaccept_btn_off';
+exports.AUTOACCEPT_BTN_REFRESH = 'autoaccept_btn_refresh';
+async function sendAutoAcceptUI(target, autoAcceptService) {
+    const enabled = autoAcceptService.isEnabled();
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('Auto-accept Management')
+        .setColor(enabled ? 0x2ECC71 : 0x95A5A6)
+        .setDescription(`**Current Status:** ${enabled ? '🟢 ON' : '⚪ OFF'}\n\n` +
+        'ON: approval dialogs are automatically allowed.\n' +
+        'OFF: approval dialogs require manual action.')
+        .setFooter({ text: 'Use buttons below to change mode' })
+        .setTimestamp();
+    const row = new discord_js_1.ActionRowBuilder().addComponents(new discord_js_1.ButtonBuilder()
+        .setCustomId(exports.AUTOACCEPT_BTN_ON)
+        .setLabel('Turn ON')
+        .setStyle(enabled ? discord_js_1.ButtonStyle.Success : discord_js_1.ButtonStyle.Secondary), new discord_js_1.ButtonBuilder()
+        .setCustomId(exports.AUTOACCEPT_BTN_OFF)
+        .setLabel('Turn OFF')
+        .setStyle(!enabled ? discord_js_1.ButtonStyle.Danger : discord_js_1.ButtonStyle.Secondary), new discord_js_1.ButtonBuilder()
+        .setCustomId(exports.AUTOACCEPT_BTN_REFRESH)
+        .setLabel('Refresh')
+        .setStyle(discord_js_1.ButtonStyle.Primary));
+    await target.editReply({
+        content: '',
+        embeds: [embed],
+        components: [row],
+    });
+}

package/dist/ui/modeUi.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendModeUI = sendModeUI;
+const discord_js_1 = require("discord.js");
+const modeService_1 = require("../services/modeService");
+/**
+ * Build and send the interactive UI for the /mode command (dropdown style)
+ */
+async function sendModeUI(target, modeService) {
+    const currentMode = modeService.getCurrentMode();
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('Mode Management')
+        .setColor(0x57F287)
+        .setDescription(`**Current Mode:** ${modeService_1.MODE_DISPLAY_NAMES[currentMode] || currentMode}\n` +
+        `${modeService_1.MODE_DESCRIPTIONS[currentMode] || ''}\n\n` +
+        `**Available Modes (${modeService_1.AVAILABLE_MODES.length})**\n` +
+        modeService_1.AVAILABLE_MODES.map(m => {
+            const icon = m === currentMode ? '[x]' : '[ ]';
+            return `${icon} **${modeService_1.MODE_DISPLAY_NAMES[m] || m}** — ${modeService_1.MODE_DESCRIPTIONS[m] || ''}`;
+        }).join('\n'))
+        .setFooter({ text: 'Select a mode from the dropdown below' })
+        .setTimestamp();
+    const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+        .setCustomId('mode_select')
+        .setPlaceholder('Select a mode...')
+        .addOptions(modeService_1.AVAILABLE_MODES.map(m => ({
+        label: modeService_1.MODE_DISPLAY_NAMES[m] || m,
+        description: modeService_1.MODE_DESCRIPTIONS[m] || '',
+        value: m,
+        default: m === currentMode,
+    })));
+    const row = new discord_js_1.ActionRowBuilder().addComponents(selectMenu);
+    await target.editReply({ content: '', embeds: [embed], components: [row] });
+}

package/dist/ui/modelsUi.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendModelsUI = sendModelsUI;
+const discord_js_1 = require("discord.js");
+/**
+ * Build and send the interactive UI for the /models command
+ */
+async function sendModelsUI(target, deps) {
+    const cdp = deps.getCurrentCdp();
+    if (!cdp) {
+        await target.editReply({ content: 'Not connected to CDP.' });
+        return;
+    }
+    const models = await cdp.getUiModels();
+    const currentModel = await cdp.getCurrentModel();
+    const quotaData = await deps.fetchQuota();
+    if (models.length === 0) {
+        await target.editReply({ content: 'Failed to retrieve model list from Antigravity.' });
+        return;
+    }
+    function formatQuota(mName, current) {
+        if (!mName)
+            return `${current ? '[x]' : '[ ]'} Unknown`;
+        const normalize = (s) => s.toLowerCase().replace(/[\s\-_]/g, '');
+        const nName = normalize(mName);
+        const q = quotaData.find(q => {
+            const nLabel = normalize(q.label);
+            const nModel = normalize(q.model || '');
+            return nLabel === nName || nModel === nName
+                || nName.includes(nLabel) || nLabel.includes(nName)
+                || (nModel && (nName.includes(nModel) || nModel.includes(nName)));
+        });
+        if (!q || !q.quotaInfo)
+            return `${current ? '[x]' : '[ ]'} ${mName}`;
+        const rem = q.quotaInfo.remainingFraction;
+        const resetTime = q.quotaInfo.resetTime ? new Date(q.quotaInfo.resetTime) : null;
+        const diffMs = resetTime ? resetTime.getTime() - Date.now() : 0;
+        let timeStr = 'Ready';
+        if (diffMs > 0) {
+            const mins = Math.ceil(diffMs / 60000);
+            if (mins < 60)
+                timeStr = `${mins}m`;
+            else
+                timeStr = `${Math.floor(mins / 60)}h ${mins % 60}m`;
+        }
+        if (rem !== undefined && rem !== null) {
+            const percent = Math.round(rem * 100);
+            let icon = '🟢';
+            if (percent <= 20)
+                icon = '🔴';
+            else if (percent <= 50)
+                icon = '🟡';
+            return `${current ? '[x]' : '[ ]'} ${mName} ${icon} ${percent}% (⏱️ ${timeStr})`;
+        }
+        return `${current ? '[x]' : '[ ]'} ${mName} (⏱️ ${timeStr})`;
+    }
+    const currentModelFormatted = currentModel ? formatQuota(currentModel, true) : 'Unknown';
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('Model Management')
+        .setColor(0x5865F2)
+        .setDescription(`**Current Model:**\n${currentModelFormatted}\n\n` +
+        `**Available Models (${models.length})**\n` +
+        models.map(m => formatQuota(m, m === currentModel)).join('\n'))
+        .setFooter({ text: 'Latest quota information retrieved' })
+        .setTimestamp();
+    const rows = [];
+    let currentRow = new discord_js_1.ActionRowBuilder();
+    for (const mName of models.slice(0, 24)) {
+        if (currentRow.components.length === 5) {
+            rows.push(currentRow);
+            currentRow = new discord_js_1.ActionRowBuilder();
+        }
+        const safeName = mName.length > 80 ? mName.substring(0, 77) + '...' : mName;
+        currentRow.addComponents(new discord_js_1.ButtonBuilder()
+            .setCustomId(`model_btn_${mName}`)
+            .setLabel(safeName)
+            .setStyle(mName === currentModel ? discord_js_1.ButtonStyle.Success : discord_js_1.ButtonStyle.Secondary));
+    }
+    if (currentRow.components.length < 5) {
+        currentRow.addComponents(new discord_js_1.ButtonBuilder()
+            .setCustomId('model_refresh_btn')
+            .setLabel('Refresh')
+            .setStyle(discord_js_1.ButtonStyle.Primary));
+        rows.push(currentRow);
+    }
+    else {
+        rows.push(currentRow);
+        if (rows.length < 5) {
+            const refreshRow = new discord_js_1.ActionRowBuilder().addComponents(new discord_js_1.ButtonBuilder()
+                .setCustomId('model_refresh_btn')
+                .setLabel('Refresh')
+                .setStyle(discord_js_1.ButtonStyle.Primary));
+            rows.push(refreshRow);
+        }
+    }
+    await target.editReply({ content: '', embeds: [embed], components: rows });
+}

package/dist/ui/screenshotUi.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleScreenshot = handleScreenshot;
+const discord_js_1 = require("discord.js");
+const screenshotService_1 = require("../services/screenshotService");
+/**
+ * Capture a screenshot and send it to Discord
+ */
+async function handleScreenshot(target, cdp) {
+    if (!cdp) {
+        const content = 'Not connected to Antigravity.';
+        if (target instanceof discord_js_1.Message) {
+            await target.reply(content);
+        }
+        else {
+            await target.editReply({ content });
+        }
+        return;
+    }
+    try {
+        const screenshot = new screenshotService_1.ScreenshotService({ cdpService: cdp });
+        const result = await screenshot.capture({ format: 'png' });
+        if (result.success && result.buffer) {
+            const attachment = new discord_js_1.AttachmentBuilder(result.buffer, { name: 'screenshot.png' });
+            if (target instanceof discord_js_1.Message) {
+                await target.reply({ files: [attachment] });
+            }
+            else {
+                await target.editReply({ files: [attachment] });
+            }
+        }
+        else {
+            const content = `Screenshot failed: ${result.error}`;
+            if (target instanceof discord_js_1.Message) {
+                await target.reply(content);
+            }
+            else {
+                await target.editReply({ content });
+            }
+        }
+    }
+    catch (e) {
+        const content = `Screenshot error: ${e.message}`;
+        if (target instanceof discord_js_1.Message) {
+            await target.reply(content);
+        }
+        else {
+            await target.editReply({ content });
+        }
+    }
+}

package/dist/ui/templateUi.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATE_BTN_PREFIX = void 0;
+exports.parseTemplateButtonId = parseTemplateButtonId;
+exports.sendTemplateUI = sendTemplateUI;
+const discord_js_1 = require("discord.js");
+/** Button customId prefix. Format: template_btn_<id> */
+exports.TEMPLATE_BTN_PREFIX = 'template_btn_';
+const MAX_PROMPT_PREVIEW_LEN = 60;
+const MAX_BUTTONS = 25;
+/**
+ * Extract template ID from a button customId.
+ * Returns NaN if the customId does not match the expected format.
+ */
+function parseTemplateButtonId(customId) {
+    if (!customId.startsWith(exports.TEMPLATE_BTN_PREFIX))
+        return NaN;
+    return parseInt(customId.slice(exports.TEMPLATE_BTN_PREFIX.length), 10);
+}
+/**
+ * Build and send the template list UI with clickable buttons.
+ * Follows the same pattern as modelsUi.ts.
+ */
+async function sendTemplateUI(target, templates) {
+    if (templates.length === 0) {
+        const embed = new discord_js_1.EmbedBuilder()
+            .setTitle('Template Management')
+            .setColor(0x57F287)
+            .setDescription('No templates registered.\n\n' +
+            'Use `/template add name:<name> prompt:<prompt>` to add one.')
+            .setTimestamp();
+        await target.editReply({ content: '', embeds: [embed], components: [] });
+        return;
+    }
+    const truncate = (text, max) => text.length > max ? `${text.substring(0, max - 3)}...` : text;
+    const displayTemplates = templates.slice(0, MAX_BUTTONS);
+    const hasMore = templates.length > MAX_BUTTONS;
+    const description = displayTemplates
+        .map((tpl, i) => `**${i + 1}. ${tpl.name}**\n> ${truncate(tpl.prompt, MAX_PROMPT_PREVIEW_LEN)}`)
+        .join('\n\n');
+    const footerText = hasMore
+        ? `${templates.length - MAX_BUTTONS} templates are hidden. Use /template use <name> to execute directly.`
+        : 'Click a button to execute the template';
+    const embed = new discord_js_1.EmbedBuilder()
+        .setTitle('Template Management')
+        .setColor(0x57F287)
+        .setDescription(`**Registered Templates (${templates.length})**\n\n${description}`)
+        .setFooter({ text: footerText })
+        .setTimestamp();
+    const rows = [];
+    let currentRow = new discord_js_1.ActionRowBuilder();
+    for (const tpl of displayTemplates) {
+        if (currentRow.components.length === 5) {
+            rows.push(currentRow);
+            currentRow = new discord_js_1.ActionRowBuilder();
+        }
+        const safeLabel = tpl.name.length > 80 ? `${tpl.name.substring(0, 77)}...` : tpl.name;
+        currentRow.addComponents(new discord_js_1.ButtonBuilder()
+            .setCustomId(`${exports.TEMPLATE_BTN_PREFIX}${tpl.id}`)
+            .setLabel(safeLabel)
+            .setStyle(discord_js_1.ButtonStyle.Primary));
+    }
+    if (currentRow.components.length > 0) {
+        rows.push(currentRow);
+    }
+    await target.editReply({ content: '', embeds: [embed], components: rows });
+}