lazy-gravity 0.0.2 → 0.0.3

package/dist/commands/registerSlashCommands.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slashCommands = void 0;
+exports.registerSlashCommands = registerSlashCommands;
+const logger_1 = require("../utils/logger");
+const discord_js_1 = require("discord.js");
+const i18n_1 = require("../utils/i18n");
+/**
+ * Slash command definitions for the Discord Interactions API.
+ * Registers bot slash commands to the application.
+ */
+/** /mode command definition */
+const modeCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('mode')
+    .setDescription((0, i18n_1.t)('Display and change execution mode via a dropdown'));
+/** /model command definition (formerly /models, unified to singular) */
+const modelCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('model')
+    .setDescription((0, i18n_1.t)('Display and change available LLM models'))
+    .addStringOption((option) => option
+    .setName('name')
+    .setDescription((0, i18n_1.t)('Name of the model to change to'))
+    .setRequired(false));
+/** /template command definition (formerly /templates, unified to singular) */
+const templateCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('template')
+    .setDescription((0, i18n_1.t)('List, register, or delete templates'))
+    .addSubcommand((sub) => sub
+    .setName('list')
+    .setDescription((0, i18n_1.t)('Display registered template list with execute buttons')))
+    .addSubcommand((sub) => sub
+    .setName('add')
+    .setDescription((0, i18n_1.t)('Register a new template'))
+    .addStringOption((option) => option
+    .setName('name')
+    .setDescription((0, i18n_1.t)('Template name'))
+    .setRequired(true))
+    .addStringOption((option) => option
+    .setName('prompt')
+    .setDescription((0, i18n_1.t)('Prompt content of the template'))
+    .setRequired(true)))
+    .addSubcommand((sub) => sub
+    .setName('delete')
+    .setDescription((0, i18n_1.t)('Delete a template'))
+    .addStringOption((option) => option
+    .setName('name')
+    .setDescription((0, i18n_1.t)('Name of the template to delete'))
+    .setRequired(true)));
+/** /stop command definition */
+const stopCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('stop')
+    .setDescription((0, i18n_1.t)('Interrupt active LLM generation'));
+/** /screenshot command definition */
+const screenshotCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('screenshot')
+    .setDescription((0, i18n_1.t)('Capture current Antigravity screen'));
+/** /status command definition (formerly /cdp status, extended to overall bot status) */
+const statusCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('status')
+    .setDescription((0, i18n_1.t)('Display overall bot status including connection, model, mode'));
+/** /autoaccept command definition */
+const autoAcceptCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('autoaccept')
+    .setDescription((0, i18n_1.t)('Display and toggle auto-allow mode for approval dialogs'))
+    .addStringOption((option) => option
+    .setName('mode')
+    .setDescription((0, i18n_1.t)('on / off (optional direct switch)'))
+    .setRequired(false));
+/** /project command definition (formerly /workspace, renamed to project) */
+const projectCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('project')
+    .setDescription((0, i18n_1.t)('List projects, on select auto-create channel and bind'))
+    .addSubcommand((sub) => sub
+    .setName('list')
+    .setDescription((0, i18n_1.t)('Display project list')))
+    .addSubcommand((sub) => sub
+    .setName('create')
+    .setDescription((0, i18n_1.t)('Create a new project'))
+    .addStringOption((option) => option
+    .setName('name')
+    .setDescription((0, i18n_1.t)('Name of the project to create'))
+    .setRequired(true)));
+/** /new command definition (formerly /chat new, made into a standalone command) */
+const newCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('new')
+    .setDescription((0, i18n_1.t)('Start a new chat session in the current project'));
+/** /chat command definition (merged status + list) */
+const chatCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('chat')
+    .setDescription((0, i18n_1.t)('Display current chat session info and session list'));
+/** /cleanup command definition */
+const cleanupCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('cleanup')
+    .setDescription((0, i18n_1.t)('Scan and clean up inactive session channels and categories'))
+    .addIntegerOption((option) => option
+    .setName('days')
+    .setDescription((0, i18n_1.t)('Number of days of inactivity (default: 7)'))
+    .setRequired(false)
+    .setMinValue(1)
+    .setMaxValue(365));
+/** /help command definition */
+const helpCommand = new discord_js_1.SlashCommandBuilder()
+    .setName('help')
+    .setDescription((0, i18n_1.t)('Display list of available commands'));
+/** Array of commands to register */
+exports.slashCommands = [
+    helpCommand,
+    modeCommand,
+    modelCommand,
+    templateCommand,
+    stopCommand,
+    screenshotCommand,
+    statusCommand,
+    autoAcceptCommand,
+    projectCommand,
+    newCommand,
+    chatCommand,
+    cleanupCommand,
+];
+/**
+ * Register slash commands with Discord
+ * @param token Bot token
+ * @param clientId Bot application ID
+ * @param guildId Target guild (server) ID (global registration if omitted)
+ */
+async function registerSlashCommands(token, clientId, guildId) {
+    const rest = new discord_js_1.REST({ version: '10' }).setToken(token);
+    const commandData = exports.slashCommands.map((cmd) => cmd.toJSON());
+    try {
+        if (guildId) {
+            // Guild-specific registration (takes effect immediately)
+            await rest.put(discord_js_1.Routes.applicationGuildCommands(clientId, guildId), { body: commandData });
+            logger_1.logger.info(`Registered ${commandData.length} slash commands to guild ${guildId}.`);
+            // Clear global commands to avoid duplicate suggestions such as old legacy commands.
+            // This bot is expected to run primarily in guild scope when guildId is provided.
+            await rest.put(discord_js_1.Routes.applicationCommands(clientId), { body: [] });
+            logger_1.logger.info('Cleared global slash commands to prevent duplicate command listings.');
+        }
+        else {
+            // Global registration (may take up to 1 hour to take effect)
+            await rest.put(discord_js_1.Routes.applicationCommands(clientId), { body: commandData });
+            logger_1.logger.info(`Registered ${commandData.length} slash commands globally.`);
+        }
+    }
+    catch (error) {
+        logger_1.logger.error((0, i18n_1.t)('❌ Failed to register slash commands:'), error);
+        throw error;
+    }
+}

package/dist/commands/slashCommandHandler.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlashCommandHandler = void 0;
+const i18n_1 = require("../utils/i18n");
+class SlashCommandHandler {
+    templateRepo;
+    constructor(templateRepo) {
+        this.templateRepo = templateRepo;
+    }
+    /**
+     * Parse the slash command name and arguments, then route to the appropriate handler
+     */
+    async handleCommand(commandName, args) {
+        switch (commandName.toLowerCase()) {
+            case 'template':
+                return this.handleTemplateCommand(args);
+            default:
+                return {
+                    success: false,
+                    message: (0, i18n_1.t)(`⚠️ Unknown command: /${commandName}`),
+                };
+        }
+    }
+    handleTemplateCommand(args) {
+        if (args.length === 0) {
+            const templates = this.templateRepo.findAll();
+            if (templates.length === 0) {
+                return {
+                    success: true,
+                    message: (0, i18n_1.t)('📝 No templates registered.'),
+                };
+            }
+            const list = templates.map((t) => `- **${t.name}**`).join('\n');
+            return {
+                success: true,
+                message: (0, i18n_1.t)(`📝 Registered Templates:\n${list}\n\nTo use: \`/template [name]\``),
+            };
+        }
+        const subCommandOrName = args[0];
+        // add: register new template
+        if (subCommandOrName.toLowerCase() === 'add') {
+            if (args.length < 3) {
+                return {
+                    success: false,
+                    message: (0, i18n_1.t)('⚠️ Missing arguments.\nUsage: `/template add "name" "prompt"`'),
+                };
+            }
+            const name = args[1];
+            // Quotes already stripped by messageParser. Join remaining args as the prompt
+            const prompt = args.slice(2).join(' ');
+            try {
+                this.templateRepo.create({ name, prompt });
+                return {
+                    success: true,
+                    message: (0, i18n_1.t)(`✅ Template **${name}** registered.`),
+                };
+            }
+            catch (e) {
+                return {
+                    success: false,
+                    message: (0, i18n_1.t)(`⚠️ Failed to register template. Name might be duplicated.`),
+                };
+            }
+        }
+        // delete: remove template
+        if (subCommandOrName.toLowerCase() === 'delete') {
+            if (args.length < 2) {
+                return {
+                    success: false,
+                    message: (0, i18n_1.t)('⚠️ Specify a template name to delete.\nUsage: `/template delete "name"`'),
+                };
+            }
+            const name = args[1];
+            const deleted = this.templateRepo.deleteByName(name);
+            if (deleted) {
+                return {
+                    success: true,
+                    message: (0, i18n_1.t)(`🗑️ Template **${name}** deleted.`),
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    message: (0, i18n_1.t)(`⚠️ Template **${name}** not found.`),
+                };
+            }
+        }
+        // Otherwise treat as template invocation
+        const templateName = subCommandOrName;
+        const template = this.templateRepo.findByName(templateName);
+        if (!template) {
+            return {
+                success: false,
+                message: (0, i18n_1.t)(`⚠️ Template **${templateName}** not found.`),
+            };
+        }
+        return {
+            success: true,
+            message: (0, i18n_1.t)(`📝 Invoked template **${templateName}**.\nStarting process with this prompt.`),
+            prompt: template.prompt,
+        };
+    }
+}
+exports.SlashCommandHandler = SlashCommandHandler;

package/dist/commands/workspaceCommandHandler.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceCommandHandler = exports.WORKSPACE_SELECT_ID = exports.PROJECT_SELECT_ID = void 0;
+const i18n_1 = require("../utils/i18n");
+const fs_1 = __importDefault(require("fs"));
+const discord_js_1 = require("discord.js");
+/** Select menu custom ID */
+exports.PROJECT_SELECT_ID = 'project_select';
+/** Backward compatibility: also accept old ID */
+exports.WORKSPACE_SELECT_ID = 'workspace_select';
+/**
+ * Handler for the /project slash command.
+ * When a project is selected, auto-creates a Discord category + session-1 channel and binds them.
+ */
+class WorkspaceCommandHandler {
+    bindingRepo;
+    chatSessionRepo;
+    workspaceService;
+    channelManager;
+    processingWorkspaces = new Set();
+    constructor(bindingRepo, chatSessionRepo, workspaceService, channelManager) {
+        this.bindingRepo = bindingRepo;
+        this.chatSessionRepo = chatSessionRepo;
+        this.workspaceService = workspaceService;
+        this.channelManager = channelManager;
+    }
+    /**
+     * /project list -- Display project list via select menu
+     */
+    async handleShow(interaction) {
+        const embed = new discord_js_1.EmbedBuilder()
+            .setTitle('📁 Projects')
+            .setColor(0x5865F2)
+            .setDescription((0, i18n_1.t)('Select a project to auto-create a category and session channel'))
+            .setTimestamp();
+        const components = [];
+        const workspaces = this.workspaceService.scanWorkspaces();
+        if (workspaces.length > 0) {
+            const options = workspaces.slice(0, 25).map((ws) => ({
+                label: ws,
+                value: ws,
+            }));
+            const selectMenu = new discord_js_1.StringSelectMenuBuilder()
+                .setCustomId(exports.PROJECT_SELECT_ID)
+                .setPlaceholder((0, i18n_1.t)('Select a project...'))
+                .addOptions(options);
+            if (workspaces.length > 25) {
+                selectMenu.setPlaceholder((0, i18n_1.t)(`Select a project... (Showing 25 of ${workspaces.length})`));
+            }
+            components.push(new discord_js_1.ActionRowBuilder().addComponents(selectMenu));
+        }
+        await interaction.editReply({
+            embeds: [embed],
+            components,
+        });
+    }
+    /**
+     * Handler for when a project is selected from the select menu.
+     * Creates a category + session-1 channel and binds them.
+     */
+    async handleSelectMenu(interaction, guild) {
+        const workspacePath = interaction.values[0];
+        if (!this.workspaceService.exists(workspacePath)) {
+            await interaction.update({
+                content: (0, i18n_1.t)(`❌ Project \`${workspacePath}\` not found.`),
+                embeds: [],
+                components: [],
+            });
+            return;
+        }
+        // Check if the same project is already bound (prevent duplicates)
+        const existingBindings = this.bindingRepo.findByWorkspacePathAndGuildId(workspacePath, guild.id);
+        if (existingBindings.length > 0) {
+            const channelLinks = existingBindings.map(b => `<#${b.channelId}>`).join(', ');
+            const fullPath = this.workspaceService.getWorkspacePath(workspacePath);
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle('📁 Projects')
+                .setColor(0xFFA500)
+                .setDescription((0, i18n_1.t)(`⚠️ Project **${workspacePath}** already exists\n`) +
+                `→ ${channelLinks}`)
+                .addFields({ name: (0, i18n_1.t)('Full Path'), value: `\`${fullPath}\`` })
+                .setTimestamp();
+            await interaction.update({
+                embeds: [embed],
+                components: [],
+            });
+            return;
+        }
+        // Lock project being processed (prevent rapid repeated clicks)
+        if (this.processingWorkspaces.has(workspacePath)) {
+            await interaction.update({
+                content: (0, i18n_1.t)(`⏳ **${workspacePath}** is being created. Please wait.`),
+                embeds: [],
+                components: [],
+            });
+            return;
+        }
+        this.processingWorkspaces.add(workspacePath);
+        try {
+            // Ensure category exists
+            const categoryResult = await this.channelManager.ensureCategory(guild, workspacePath);
+            const categoryId = categoryResult.categoryId;
+            // Get session number (usually 1)
+            const sessionNumber = this.chatSessionRepo.getNextSessionNumber(categoryId);
+            const channelName = `session-${sessionNumber}`;
+            // Create session channel
+            const sessionResult = await this.channelManager.createSessionChannel(guild, categoryId, channelName);
+            const channelId = sessionResult.channelId;
+            // Register binding and session
+            this.bindingRepo.upsert({
+                channelId,
+                workspacePath,
+                guildId: guild.id,
+            });
+            this.chatSessionRepo.create({
+                channelId,
+                categoryId,
+                workspacePath,
+                sessionNumber,
+                guildId: guild.id,
+            });
+            const fullPath = this.workspaceService.getWorkspacePath(workspacePath);
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle('📁 Projects')
+                .setColor(0x00AA00)
+                .setDescription((0, i18n_1.t)(`✅ Project **${workspacePath}** created\n`) +
+                `→ <#${channelId}>`)
+                .addFields({ name: (0, i18n_1.t)('Full Path'), value: `\`${fullPath}\`` })
+                .setTimestamp();
+            await interaction.update({
+                embeds: [embed],
+                components: [],
+            });
+        }
+        finally {
+            this.processingWorkspaces.delete(workspacePath);
+        }
+        return;
+    }
+    /**
+     * /project create <name> -- Create a new project directory,
+     * auto-create a category + session-1 channel and bind them.
+     */
+    async handleCreate(interaction, guild) {
+        const name = interaction.options.getString('name', true);
+        // Path traversal check
+        let fullPath;
+        try {
+            fullPath = this.workspaceService.validatePath(name);
+        }
+        catch (e) {
+            await interaction.editReply({
+                content: (0, i18n_1.t)(`❌ Invalid project name: ${e.message}`),
+            });
+            return;
+        }
+        // Check for existing project
+        if (this.workspaceService.exists(name)) {
+            const existingBindings = this.bindingRepo.findByWorkspacePathAndGuildId(name, guild.id);
+            if (existingBindings.length > 0) {
+                const channelLinks = existingBindings.map(b => `<#${b.channelId}>`).join(', ');
+                await interaction.editReply({
+                    content: (0, i18n_1.t)(`⚠️ Project **${name}** already exists → ${channelLinks}`),
+                });
+                return;
+            }
+            // Directory exists but not bound -- continue
+        }
+        // Lock project being processed
+        if (this.processingWorkspaces.has(name)) {
+            await interaction.editReply({
+                content: (0, i18n_1.t)(`⏳ **${name}** is being created.`),
+            });
+            return;
+        }
+        this.processingWorkspaces.add(name);
+        try {
+            if (!this.workspaceService.exists(name)) {
+                // Create directory
+                fs_1.default.mkdirSync(fullPath, { recursive: true });
+            }
+            // Ensure category exists
+            const categoryResult = await this.channelManager.ensureCategory(guild, name);
+            const categoryId = categoryResult.categoryId;
+            // Get session number (usually 1)
+            const sessionNumber = this.chatSessionRepo.getNextSessionNumber(categoryId);
+            const channelName = `session-${sessionNumber}`;
+            // Create session channel
+            const sessionResult = await this.channelManager.createSessionChannel(guild, categoryId, channelName);
+            const channelId = sessionResult.channelId;
+            // Register binding and session
+            this.bindingRepo.upsert({
+                channelId,
+                workspacePath: name,
+                guildId: guild.id,
+            });
+            this.chatSessionRepo.create({
+                channelId,
+                categoryId,
+                workspacePath: name,
+                sessionNumber,
+                guildId: guild.id,
+            });
+            const embed = new discord_js_1.EmbedBuilder()
+                .setTitle('📁 Project Created')
+                .setColor(0x00AA00)
+                .setDescription((0, i18n_1.t)(`✅ Project **${name}** created\n`) +
+                `→ <#${channelId}>`)
+                .addFields({ name: (0, i18n_1.t)('Full Path'), value: `\`${fullPath}\`` })
+                .setTimestamp();
+            await interaction.editReply({ embeds: [embed] });
+        }
+        finally {
+            this.processingWorkspaces.delete(name);
+        }
+    }
+    /**
+     * Get the bound project path from a channel ID
+     */
+    getWorkspaceForChannel(channelId) {
+        const binding = this.bindingRepo.findByChannelId(channelId);
+        if (!binding)
+            return undefined;
+        return this.workspaceService.getWorkspacePath(binding.workspacePath);
+    }
+}
+exports.WorkspaceCommandHandler = WorkspaceCommandHandler;

package/dist/database/chatSessionRepository.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatSessionRepository = void 0;
+/**
+ * Repository for persisting Discord channel to chat session mapping in SQLite.
+ * One session per channel (UNIQUE constraint).
+ */
+class ChatSessionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    initialize() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS chat_sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                channel_id TEXT NOT NULL UNIQUE,
+                category_id TEXT NOT NULL,
+                workspace_path TEXT NOT NULL,
+                session_number INTEGER NOT NULL,
+                display_name TEXT,
+                is_renamed INTEGER NOT NULL DEFAULT 0,
+                guild_id TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    create(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO chat_sessions (channel_id, category_id, workspace_path, session_number, guild_id)
+            VALUES (?, ?, ?, ?, ?)
+        `);
+        const result = stmt.run(input.channelId, input.categoryId, input.workspacePath, input.sessionNumber, input.guildId);
+        return {
+            id: result.lastInsertRowid,
+            channelId: input.channelId,
+            categoryId: input.categoryId,
+            workspacePath: input.workspacePath,
+            sessionNumber: input.sessionNumber,
+            displayName: null,
+            isRenamed: false,
+            guildId: input.guildId,
+        };
+    }
+    findByChannelId(channelId) {
+        const row = this.db.prepare('SELECT * FROM chat_sessions WHERE channel_id = ?').get(channelId);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    findByCategoryId(categoryId) {
+        const rows = this.db.prepare('SELECT * FROM chat_sessions WHERE category_id = ? ORDER BY session_number ASC').all(categoryId);
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Get the next session number within a category (MAX + 1, or 1 if none)
+     */
+    getNextSessionNumber(categoryId) {
+        const row = this.db.prepare('SELECT MAX(session_number) as max_num FROM chat_sessions WHERE category_id = ?').get(categoryId);
+        return (row?.max_num ?? 0) + 1;
+    }
+    /**
+     * Update session display name and set is_renamed to true
+     */
+    updateDisplayName(channelId, displayName) {
+        const result = this.db.prepare('UPDATE chat_sessions SET display_name = ?, is_renamed = 1 WHERE channel_id = ?').run(displayName, channelId);
+        return result.changes > 0;
+    }
+    deleteByChannelId(channelId) {
+        const result = this.db.prepare('DELETE FROM chat_sessions WHERE channel_id = ?').run(channelId);
+        return result.changes > 0;
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            channelId: row.channel_id,
+            categoryId: row.category_id,
+            workspacePath: row.workspace_path,
+            sessionNumber: row.session_number,
+            displayName: row.display_name,
+            isRenamed: row.is_renamed === 1,
+            guildId: row.guild_id,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.ChatSessionRepository = ChatSessionRepository;

package/dist/database/scheduleRepository.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleRepository = void 0;
+/**
+ * Repository class for SQLite persistence of scheduled jobs.
+ * Handles saving, retrieving, updating, and deleting cron expressions and prompts.
+ */
+class ScheduleRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+        this.initialize();
+    }
+    /**
+     * Initialize table (create if not exists)
+     */
+    initialize() {
+        this.db.exec(`
+            CREATE TABLE IF NOT EXISTS schedules (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                cron_expression TEXT NOT NULL,
+                prompt TEXT NOT NULL,
+                workspace_path TEXT NOT NULL,
+                enabled INTEGER NOT NULL DEFAULT 1,
+                created_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+        `);
+    }
+    /**
+     * Create a new schedule
+     */
+    create(input) {
+        const stmt = this.db.prepare(`
+            INSERT INTO schedules (cron_expression, prompt, workspace_path, enabled)
+            VALUES (?, ?, ?, ?)
+        `);
+        const result = stmt.run(input.cronExpression, input.prompt, input.workspacePath, input.enabled ? 1 : 0);
+        return {
+            id: result.lastInsertRowid,
+            cronExpression: input.cronExpression,
+            prompt: input.prompt,
+            workspacePath: input.workspacePath,
+            enabled: input.enabled,
+        };
+    }
+    /**
+     * Get all schedules
+     */
+    findAll() {
+        const rows = this.db.prepare('SELECT * FROM schedules ORDER BY id ASC').all();
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Get a schedule by ID
+     */
+    findById(id) {
+        const row = this.db.prepare('SELECT * FROM schedules WHERE id = ?').get(id);
+        if (!row)
+            return undefined;
+        return this.mapRow(row);
+    }
+    /**
+     * Get only enabled schedules (for re-registration on bot startup)
+     */
+    findEnabled() {
+        const rows = this.db.prepare('SELECT * FROM schedules WHERE enabled = 1 ORDER BY id ASC').all();
+        return rows.map(this.mapRow);
+    }
+    /**
+     * Delete a schedule
+     */
+    delete(id) {
+        const result = this.db.prepare('DELETE FROM schedules WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    /**
+     * Partially update a schedule
+     */
+    update(id, input) {
+        const sets = [];
+        const values = [];
+        if (input.cronExpression !== undefined) {
+            sets.push('cron_expression = ?');
+            values.push(input.cronExpression);
+        }
+        if (input.prompt !== undefined) {
+            sets.push('prompt = ?');
+            values.push(input.prompt);
+        }
+        if (input.workspacePath !== undefined) {
+            sets.push('workspace_path = ?');
+            values.push(input.workspacePath);
+        }
+        if (input.enabled !== undefined) {
+            sets.push('enabled = ?');
+            values.push(input.enabled ? 1 : 0);
+        }
+        if (sets.length === 0)
+            return false;
+        values.push(id);
+        const sql = `UPDATE schedules SET ${sets.join(', ')} WHERE id = ?`;
+        const result = this.db.prepare(sql).run(...values);
+        return result.changes > 0;
+    }
+    /**
+     * Map a DB row to ScheduleRecord
+     */
+    mapRow(row) {
+        return {
+            id: row.id,
+            cronExpression: row.cron_expression,
+            prompt: row.prompt,
+            workspacePath: row.workspace_path,
+            enabled: row.enabled === 1,
+            createdAt: row.created_at,
+        };
+    }
+}
+exports.ScheduleRepository = ScheduleRepository;